home *** CD-ROM | disk | FTP | other *** search
/ FM Towns: Free Software Collection 9 / FM Towns Free Software Collection 9.iso / t_os / tool / helper / src / file.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-11-16  |  53.7 KB  |  2,359 lines
  1. #include    <stdio.h>
  2. #include    <stdlib.h>
  3. #include    <stdarg.h>
  4. #include    <string.h>
  5. #include    <ctype.h>
  6. #include    <mos.h>
  7. #include    "dir.h"
  8. #include    "scrn.h"
  9. #include    "keyword.h"
  10. #include    "graphic.h"
  11. #include    "event.h"
  12. #include    "coldef.h"
  13. #include    "bitmap.h"
  14.  
  15. #define    TRUE    1
  16. #define    FALSE    0
  17. #define    ERR    (-1)
  18.  
  19. #define    LIN_MAX        80
  20. #define    TAB        8
  21. #define    LPT_LINE    59
  22.  
  23. #define    PAGE        0x40000
  24.  
  25. #define    MAX_Y        25
  26. #define    SCRN_Y        52
  27.  
  28. #define    SCRN_X1        0
  29. #define    SCRN_Y1        47
  30. #define    SCRN_X2        639
  31. #define    SCRN_Y2        454
  32.  
  33. #define    BAR_SIZ        (25*8)
  34. #define    BAR_X1        8
  35. #define    BAR_Y1        458
  36. #define    BAR_X2        (BAR_X1+BAR_SIZ+4)
  37. #define    BAR_Y2        (BAR_Y1+19)
  38.  
  39. #define    KAKU_X1        (15*8-4)
  40. #define    KAKU_Y1        180
  41. #define    KAKU_X2        (64*8+3)
  42. #define    KAKU_Y2        280
  43.  
  44. #define    KAKU_MSG_X    ((KAKU_X1+KAKU_X2)/2)
  45. #define    KAKU_MSG_Y    (KAKU_Y1+30)
  46.  
  47. #define    KAKU_CHK_X    ((KAKU_X1+KAKU_X2)/2-(4*8))
  48. #define    KAKU_CHK_Y    (KAKU_Y1+70)
  49.  
  50. #define    KAKU_YES_X    ((KAKU_X1+KAKU_X2)/2-(10*8))
  51. #define    KAKU_YES_Y    (KAKU_Y1+70)
  52.  
  53. #define    KAKU_NO_X    ((KAKU_X1+KAKU_X2)/2+(2*8))
  54. #define    KAKU_NO_Y    (KAKU_Y1+70)
  55.  
  56. #define    BREAK_X1    (13*8-4)
  57. #define    BREAK_Y1    160
  58. #define    BREAK_X2    (66*8+3)
  59. #define    BREAK_Y2    300
  60.  
  61. #define    BREAK_MSG_X    ((BREAK_X1+BREAK_X2)/2)
  62. #define    BREAK_MSG_Y    (BREAK_Y1+30)
  63.  
  64. #define    BREAK_BAR_SIZ    (41*8)
  65. #define    BREAK_BAR_X    (BREAK_X1+6*8)
  66. #define    BREAK_BAR_Y    (BREAK_Y1+70)
  67.  
  68. #define    BREAK_BAR_X1    (BREAK_BAR_X-2)
  69. #define    BREAK_BAR_Y1    (BREAK_BAR_Y-2)
  70. #define    BREAK_BAR_X2    (BREAK_BAR_X+BREAK_BAR_SIZ+2)
  71. #define    BREAK_BAR_Y2    (BREAK_BAR_Y+17)
  72.  
  73. #define    BREAK_CHK_X    ((BREAK_X1+BREAK_X2)/2-(4*8))
  74. #define    BREAK_CHK_Y    (BREAK_Y1+110)
  75.  
  76. typedef struct _LP {
  77.     struct _LP    *next;
  78.     struct _LP    *back;
  79.     char        buf[1];
  80. } LINPTR;
  81.  
  82. void    INKEY_start(void);
  83. void    INKEY_end(void);
  84. int    getch(void);
  85. int    CLIP_box();
  86.  
  87. extern int    cur_x;
  88. extern int    cur_y;
  89.  
  90.        int      cut_mode = FALSE;
  91.        char     cut_buf[2][128];
  92.  
  93. static int    old_line=(-1);
  94. static int    now_line=0;
  95. static int    max_line=0;
  96. static int    now_ofs=0;
  97. static int    slow_ofs=0;
  98. static int    scr_speed = 0;
  99. static int      old_timer = 0;
  100. static int    bar_old_x1=(-1);
  101. static int    bar_old_x2=(-1);
  102. static LINPTR    *top_ptr=NULL;
  103. static LINPTR    *now_ptr=NULL;
  104. static BLOCK    *save=NULL;
  105. static char    file_name[128];
  106. static int    break_bar=0;
  107. static BLOCK    *break_save=NULL;
  108. static EVENT    *break_ep=NULL;
  109.  
  110. int    pause(char *form,...)
  111. {
  112.     va_list arg;
  113.     int     n,x1,x2;
  114.     int     cd,sw,bx,by;
  115.     BLOCK   *sp;
  116.     EVENT   *ep=NULL;
  117.     char    tmp[256];
  118.  
  119.     va_start(arg,form);
  120.     vsprintf((char *)tmp,form,arg);
  121.     va_end(arg);
  122.  
  123.     if ( (n = (strlen(tmp) * 8 + 32) / 2) < 160 )
  124.     n = 160;
  125.     x1 = (KAKU_X1 + KAKU_X2) / 2 - n;
  126.     x2 = (KAKU_X1 + KAKU_X2) / 2 + n;
  127.  
  128.     MOS_disp(OFF);
  129.     sp = DSP_push_vram(x1,KAKU_Y1,x2,KAKU_Y2);
  130.     DSP_opbox(x1,KAKU_Y1,x2,KAKU_Y2);
  131.     DSP_wbox(x1,KAKU_Y1,x2,KAKU_Y2,LINE_COL,FILD_COL,M_PSET);
  132.     gputs(KAKU_MSG_X-strlen(tmp)*4,KAKU_MSG_Y,CHR_COL,FILD_COL,tmp);
  133.  
  134. /*******
  135.     ep = EVT_sw(ep,0,KAKU_YES_X,KAKU_YES_Y,CHR_COL,WIND_COL,"CONTINUE");
  136.     ep = EVT_sw(ep,1,KAKU_NO_X,KAKU_NO_Y,CHR_COL,WIND_COL,  " CANCEL ");
  137. ********/
  138.     ep = EVT_img(ep,0,KAKU_YES_X,KAKU_YES_Y,CHR_COL,WIND_COL,64,continue_img);
  139.     ep = EVT_img(ep,1,KAKU_NO_X,KAKU_NO_Y,CHR_COL,WIND_COL,  64,cancel_img);
  140.  
  141.     MOS_rdpos(&sw,&bx,&by);
  142.     MOS_setpos((KAKU_X1+KAKU_X2)/2,KAKU_YES_Y+8);
  143.     MOS_disp(ON);
  144.  
  145.     cd = (EVT_wait(ep) == 0 ? TRUE:ERR);
  146.     EVT_free(ep);
  147.  
  148.     MOS_disp(OFF);
  149.     DSP_pop_vram(sp);
  150.     DSP_clbox(x1,KAKU_Y1,x2,KAKU_Y2);
  151.     MOS_setpos(bx,by);
  152.     MOS_disp(ON);
  153.  
  154.     return cd;
  155. }
  156. int    yesno2(char *form,...)
  157. {
  158.     va_list arg;
  159.     int     n,x1,x2;
  160.     int     cd,sw,bx,by;
  161.     BLOCK   *sp;
  162.     EVENT   *ep=NULL;
  163.     char    tmp[256];
  164.  
  165.     va_start(arg,form);
  166.     vsprintf((char *)tmp,form,arg);
  167.     va_end(arg);
  168.  
  169.     if ( (n = (strlen(tmp) * 8 + 32) / 2) < 160 )
  170.     n = 160;
  171.     x1 = (KAKU_X1 + KAKU_X2) / 2 - n;
  172.     x2 = (KAKU_X1 + KAKU_X2) / 2 + n;
  173.  
  174.     MOS_disp(OFF);
  175.     sp = DSP_push_vram(x1,KAKU_Y1,x2,KAKU_Y2);
  176.     DSP_opbox(x1,KAKU_Y1,x2,KAKU_Y2);
  177.     DSP_wbox(x1,KAKU_Y1,x2,KAKU_Y2,LINE_COL,FILD_COL,M_PSET);
  178.     gputs(KAKU_MSG_X-strlen(tmp)*4,KAKU_MSG_Y,CHR_COL,FILD_COL,tmp);
  179.  
  180. /*********
  181.     ep = EVT_sw(ep,0,KAKU_YES_X,KAKU_YES_Y,CHR_COL,WIND_COL,"  YES  ");
  182.     ep = EVT_sw(ep,1,KAKU_NO_X,KAKU_NO_Y,CHR_COL,WIND_COL,  "   NO  ");
  183. **********/
  184.     ep = EVT_img(ep,0,KAKU_YES_X,KAKU_YES_Y,CHR_COL,WIND_COL,64,yes_img);
  185.     ep = EVT_img(ep,1,KAKU_NO_X,KAKU_NO_Y,CHR_COL,WIND_COL,  64,no_img);
  186.  
  187.     MOS_rdpos(&sw,&bx,&by);
  188.     MOS_setpos((KAKU_X1+KAKU_X2)/2,KAKU_YES_Y+8);
  189.     MOS_disp(ON);
  190.  
  191.     cd = (EVT_wait(ep) == 0 ? TRUE:ERR);
  192.     EVT_free(ep);
  193.  
  194.     MOS_disp(OFF);
  195.     DSP_pop_vram(sp);
  196.     DSP_clbox(x1,KAKU_Y1,x2,KAKU_Y2);
  197.     MOS_setpos(bx,by);
  198.     MOS_disp(ON);
  199.  
  200.     return cd;
  201. }
  202. int    yesno(char *form,...)
  203. {
  204.     va_list arg;
  205.     int     n,x1,x2;
  206.     int     cd,sw,bx,by;
  207.     BLOCK   *sp;
  208.     EVENT   *ep=NULL;
  209.     char    tmp[256];
  210.  
  211.     va_start(arg,form);
  212.     vsprintf((char *)tmp,form,arg);
  213.     va_end(arg);
  214.  
  215.     if ( (n = (strlen(tmp) * 8 + 32) / 2) < 160 )
  216.     n = 160;
  217.     x1 = (KAKU_X1 + KAKU_X2) / 2 - n;
  218.     x2 = (KAKU_X1 + KAKU_X2) / 2 + n;
  219.  
  220.     MOS_disp(OFF);
  221.     sp = DSP_push_vram(x1,KAKU_Y1,x2,KAKU_Y2);
  222.     DSP_opbox(x1,KAKU_Y1,x2,KAKU_Y2);
  223.     DSP_wbox(x1,KAKU_Y1,x2,KAKU_Y2,LINE_COL,FILD_COL,M_PSET);
  224.     gputs(KAKU_MSG_X-strlen(tmp)*4,KAKU_MSG_Y,CHR_COL,FILD_COL,tmp);
  225.  
  226. /***********
  227.     ep = EVT_sw(ep,0,KAKU_YES_X,KAKU_YES_Y,CHR_COL,WIND_COL,"  YES  ");
  228.     ep = EVT_sw(ep,1,KAKU_NO_X,KAKU_NO_Y,CHR_COL,WIND_COL,  "   NO  ");
  229. ***********/
  230.     ep = EVT_img(ep,0,KAKU_YES_X,KAKU_YES_Y,CHR_COL,WIND_COL,64,yes_img);
  231.     ep = EVT_img(ep,1,KAKU_NO_X,KAKU_NO_Y,CHR_COL,WIND_COL,  64,no_img);
  232.  
  233.     MOS_rdpos(&sw,&bx,&by);
  234.     MOS_setpos((KAKU_X1+KAKU_X2)/2,KAKU_YES_Y+8);
  235.     MOS_disp(ON);
  236.  
  237.     cd = (EVT_wait(ep) == 0 ? TRUE:ERR);
  238.     EVT_free(ep);
  239.  
  240.     MOS_disp(OFF);
  241.     DSP_pop_vram(sp);
  242.     DSP_clbox(x1,KAKU_Y1,x2,KAKU_Y2);
  243.     MOS_setpos(bx,by);
  244.     MOS_disp(ON);
  245.  
  246.     return cd;
  247. }
  248. void    kakunin(char *form,...)
  249. {
  250.     va_list arg;
  251.     int     n,x1,x2;
  252.     int     sw,bx,by;
  253.     BLOCK   *sp;
  254.     EVENT   *ep=NULL;
  255.     char    tmp[256];
  256.  
  257.     va_start(arg,form);
  258.     vsprintf((char *)tmp,form,arg);
  259.     va_end(arg);
  260.  
  261.     if ( (n = (strlen(tmp) * 8 + 32) / 2) < 160 )
  262.     n = 160;
  263.     x1 = (KAKU_X1 + KAKU_X2) / 2 - n;
  264.     x2 = (KAKU_X1 + KAKU_X2) / 2 + n;
  265.  
  266.     MOS_disp(OFF);
  267.     sp = DSP_push_vram(x1,KAKU_Y1,x2,KAKU_Y2);
  268.     DSP_opbox(x1,KAKU_Y1,x2,KAKU_Y2);
  269.     DSP_wbox(x1,KAKU_Y1,x2,KAKU_Y2,ERR_COL,FILD_COL,M_PSET);
  270.     gputs(KAKU_MSG_X-strlen(tmp)*4,KAKU_MSG_Y,ERR_COL,FILD_COL,tmp);
  271.  
  272. /******
  273.     ep = EVT_sw(ep,0,KAKU_CHK_X,KAKU_CHK_Y,ERR_COL,WIND_COL," CHECK ");
  274. *******/
  275.     ep = EVT_img(ep,0,KAKU_CHK_X,KAKU_CHK_Y,ERR_COL,WIND_COL,64,check_img);
  276.  
  277.     MOS_rdpos(&sw,&bx,&by);
  278.     MOS_setpos((KAKU_X1+KAKU_X2)/2,KAKU_CHK_Y+8);
  279.     MOS_disp(ON);
  280.  
  281.     EVT_wait(ep);
  282.     EVT_free(ep);
  283.  
  284.     MOS_disp(OFF);
  285.     DSP_pop_vram(sp);
  286.     DSP_clbox(x1,KAKU_Y1,x2,KAKU_Y2);
  287.     MOS_setpos(bx,by);
  288.     MOS_disp(ON);
  289. }
  290. void    BREAK_open(char *form,...)
  291. {
  292.     va_list arg;
  293.     char    tmp[256];
  294.  
  295.     va_start(arg,form);
  296.     vsprintf((char *)tmp,form,arg);
  297.     va_end(arg);
  298.  
  299.     if ( break_save != NULL ) {
  300.     MOS_disp(OFF);
  301.     gputs(BREAK_MSG_X-strlen(tmp)*4,BREAK_MSG_Y, CHR_COL,FILD_COL,tmp);
  302.     MOS_disp(ON);
  303.     EVT_msg_no = ERR;
  304.     return;
  305.     }
  306.  
  307.     MOS_disp(OFF);
  308.     break_save = DSP_push_vram(BREAK_X1,BREAK_Y1,BREAK_X2,BREAK_Y2);
  309.     DSP_opbox(BREAK_X1,BREAK_Y1,BREAK_X2,BREAK_Y2);
  310.     DSP_wbox(BREAK_X1,BREAK_Y1,BREAK_X2,BREAK_Y2,
  311.                     LINE_COL,FILD_COL,M_PSET);
  312.     DSP_rbox(BREAK_BAR_X1,BREAK_BAR_Y1,BREAK_BAR_X2,BREAK_BAR_Y2,
  313.                     LINE_COL,WIND_COL,M_PSET);
  314.     gputs(BREAK_MSG_X-strlen(tmp)*4,BREAK_MSG_Y,
  315.                     CHR_COL,FILD_COL,tmp);
  316. /*******
  317.     break_ep = EVT_sw(NULL,0,BREAK_CHK_X,BREAK_CHK_Y,
  318.                     CHR_COL,WIND_COL," ABORT ");
  319. *******/
  320.     break_ep = EVT_img(NULL,0,BREAK_CHK_X,BREAK_CHK_Y,
  321.                     CHR_COL,WIND_COL,64,abort_img);
  322.  
  323.     DSP_mos(2);
  324.     MOS_disp(ON);
  325.  
  326.     break_bar = 0;
  327.     EVT_msg_no = ERR;
  328. }
  329. int    BREAK_chk(int max, int pos)
  330. {
  331.     int     n;
  332.  
  333.     if ( max > 0 ) {
  334.     n = BREAK_BAR_SIZ * pos / max;
  335.     if ( break_bar != n ) {
  336.         MOS_disp(OFF);
  337.         if ( n > break_bar )
  338.         DSP_box(BREAK_BAR_X + break_bar, BREAK_BAR_Y,
  339.             BREAK_BAR_X + n, BREAK_BAR_Y + 15,
  340.             7, M_PSET);
  341.         else
  342.         DSP_box(BREAK_BAR_X + n + 1, BREAK_BAR_Y,
  343.             BREAK_BAR_X + break_bar, BREAK_BAR_Y + 15,
  344.             WIND_COL, M_PSET);
  345.         MOS_disp(ON);
  346.     }
  347.     break_bar = n;
  348.     }
  349.  
  350.     EVT_loop(break_ep);
  351.  
  352.     return (EVT_msg_no == 0 ? TRUE:FALSE);
  353. }
  354. void    BREAK_close(void)
  355. {
  356.     EVT_free(break_ep); break_ep = NULL;
  357.     MOS_disp(OFF);
  358.     DSP_pop_vram(break_save); break_save = NULL;
  359.     DSP_clbox(BREAK_X1,BREAK_Y1,BREAK_X2,BREAK_Y2);
  360.     DSP_mos(0);
  361.     MOS_disp(ON);
  362. }
  363. static LINPTR  *get_ptr(str)
  364. char    *str;
  365. {
  366.     register LINPTR *lp;
  367.  
  368.     if ( (lp = (LINPTR *)malloc(strlen(str)+sizeof(LINPTR))) != NULL ) {
  369.         lp->next = lp->back = NULL;
  370.     strcpy(lp->buf,str);
  371.     }
  372.     return lp;
  373. }
  374. static LINPTR  *read_line(fp)
  375. FILE    *fp;
  376. {
  377.     int     i,j,ch;
  378.     char    tmp[LIN_MAX + 1];
  379.  
  380.     for ( i = 0 ; i < LIN_MAX ; ) {
  381.         if ( (ch = getc(fp)) == EOF || ch == '\n' )
  382.             break;
  383.     if ( iskanji(ch) ) {
  384.             if ( i == (LIN_MAX - 1) ) {
  385.                 ungetc(ch,fp);
  386.         break;
  387.             }
  388.         tmp[i++] = ch;
  389.             if ( (ch = getc(fp)) == EOF ) {
  390.                 i--;
  391.                 break;
  392.             }
  393.             tmp[i++] = ch;
  394.         } else if ( ch == '\t' ) {
  395.         j = TAB - (i % TAB);
  396.         while ( i < LIN_MAX && j-- > 0 )
  397.         tmp[i++] = ' ';
  398.     } else
  399.         tmp[i++] = ch;
  400.     }
  401.     tmp[i] = '\0';
  402.  
  403.     if ( tmp[0] == '\0' && feof(fp) )
  404.     return NULL;
  405.  
  406.     return get_ptr(tmp);
  407. }
  408. static LINPTR    *read_file(file)
  409. char    *file;
  410. {
  411.     FILE    *fp;
  412.     LINPTR  *lp;
  413.     LINPTR  tp;
  414.     char    *p;
  415.  
  416.     file_name[0] = '\0';
  417.  
  418.     if ( file == NULL || (fp = fopen(file,"r")) == NULL )
  419.     return NULL;
  420.  
  421.     strcpy(file_name,file);
  422.     if ( (p = strrchr(file_name,'\\')) != NULL )
  423.     *p = '\0';
  424.  
  425.     lp = &tp;
  426.     while ( (lp->next = read_line(fp)) != NULL ) {
  427.     lp->next->back = lp;
  428.     lp = lp->next;
  429.     max_line++;
  430.     }
  431.  
  432.     fclose(fp);
  433.     if ( tp.next != NULL )
  434.     tp.next->back = NULL;
  435.     return tp.next;
  436. }
  437. static void    free_file(LINPTR *tp)
  438. {
  439.     LINPTR *lp;
  440.  
  441.     while ( tp != NULL ) {
  442.     lp = tp->next;
  443.     free(tp);
  444.     tp = lp;
  445.     }
  446. }
  447. static void    scrool_bar_disp(void)
  448. {
  449.     int     x1,x2,s;
  450.  
  451.     if ( (s = max_line - now_line) > MAX_Y )
  452.     s = MAX_Y;
  453.  
  454.     if ( bar_old_x1 == (-1) )
  455.     DSP_rbox(BAR_X1,BAR_Y1,BAR_X2,BAR_Y2,LINE_COL,PRG_COL,M_PSET);
  456.     else
  457.     DSP_box(bar_old_x1,BAR_Y1+2,bar_old_x2,BAR_Y2-2,PRG_COL,M_PSET);
  458.  
  459.     if ( max_line > 0 ) {
  460.         x1 = BAR_X1 + 2 + BAR_SIZ * now_line / max_line;
  461.         x2 = BAR_X1 + 2 + BAR_SIZ * (now_line + s) / max_line;
  462.     DSP_box(x1,BAR_Y1+2,x2,BAR_Y2-2,XPRG_COL,M_PSET);
  463.     bar_old_x1 = x1;
  464.     bar_old_x2 = x2;
  465.     }
  466.  
  467.     MENU_mask(BACK_NO,now_line > 0 ? ON:OFF);
  468.     MENU_mask(NEXT_NO,(now_line + MAX_Y) < max_line ? ON:OFF);
  469. }
  470. static void    FILE_disp(int line)
  471. {
  472.     int     i;
  473.     LINPTR  *tp;
  474.  
  475.     while ( line > now_line && now_ptr != NULL && now_ptr->next != NULL ) {
  476.     now_line++;
  477.     now_ptr = now_ptr->next;
  478.     }
  479.     while ( line < now_line && now_ptr != NULL && now_ptr->back != NULL ) {
  480.     now_line--;
  481.     now_ptr = now_ptr->back;
  482.     }
  483.  
  484.     if ( old_line == now_line )
  485.     return;
  486.     old_line = now_line;
  487.  
  488.     MOS_disp(OFF);
  489.     now_ofs += slow_ofs; now_ofs &= 511;
  490.     slow_ofs = scr_speed = 0;
  491.     DSP_offset(1,0,(now_ofs - SCRN_Y)&511);
  492.     tp = now_ptr;
  493.     for ( i = 0 ; i < MAX_Y ; i++ ) {
  494.     if ( tp != NULL ) {
  495.         putstr(tp->buf,PAGE,(i*16+now_ofs)&511);
  496.         tp = tp->next;
  497.     } else
  498.         putstr("",PAGE,(i*16+now_ofs)&511);
  499.     }
  500.     scrool_bar_disp();
  501.     MOS_disp(ON);
  502. }
  503. void    FILE_open(char *file)
  504. {
  505.     MOS_disp(OFF);
  506.     if ( save == NULL )
  507.     save = DSP_push_vram(SCRN_X1,SCRN_Y1,SCRN_X2,479);
  508.     DSP_rbox(SCRN_X1,SCRN_Y1,SCRN_X2,SCRN_Y2,LINE_COL,SCRN_COL,M_PSET);
  509.     gputs(240,220,MENU_COL,SCRN_COL,"Now Loading......");
  510.     DSP_mos(2);
  511.     MOS_disp(ON);
  512.  
  513.     free_file(top_ptr);
  514.     bar_old_x1 = bar_old_x2 = old_line = (-1);
  515.     max_line = now_line = 0;
  516.     slow_ofs = now_ofs = 0;
  517.     top_ptr = now_ptr = read_file(file);
  518.     cut_buf[0][0] = cut_buf[1][0] = '\0';
  519.     FILE_disp(now_line);
  520.  
  521.     MOS_disp(OFF);
  522.     DSP_offset(1,0,(now_ofs - SCRN_Y)&511);
  523.     DSP_box(0,SCRN_Y,639,SCRN_Y+MAX_Y*16-1,0,M_PSET);
  524.     gprintf(49*8,460,CHR_COL,PRG_COL,"%-30.30s",file_name);
  525.     DSP_mos(0);
  526.     MOS_disp(ON);
  527.     MENU_mask(PRNT_NO,top_ptr == NULL ? OFF:ON);
  528. }
  529. void    FILE_close(void)
  530. {
  531.     free_file(top_ptr);
  532.     top_ptr = now_ptr = NULL;
  533.     MOS_disp(OFF);
  534.     DSP_pop_vram(save);
  535.     DSP_clear(1);
  536.     MOS_disp(ON);
  537.     save = NULL;
  538. }
  539. void    FILE_redisp()
  540. {
  541.     if ( save == NULL || top_ptr == NULL )
  542.     return;
  543.     old_line = (-1);
  544.     FILE_disp(now_line);
  545. }
  546. void    FILE_back(void)
  547. {
  548.     if ( top_ptr == NULL || now_line <= 0 )
  549.     return;
  550.     FILE_disp(now_line - MAX_Y);
  551. }
  552. void    FILE_next(void)
  553. {
  554.     if ( top_ptr == NULL || (now_line + MAX_Y) >= max_line )
  555.     return;
  556.     FILE_disp(now_line + MAX_Y);
  557. }
  558. static    int    FILE_one_up(void)
  559. {
  560.     int     i;
  561.     LINPTR  *tp;
  562.  
  563.     if ( (now_line + MAX_Y) >= max_line ||
  564.      now_ptr == NULL || now_ptr->next == NULL )
  565.     return ERR;
  566.  
  567.     now_line++;
  568.     old_line++;
  569.     tp = now_ptr = now_ptr->next;
  570.     for ( i = 1 ; tp != NULL && i < MAX_Y ; i++ )
  571.     tp = tp->next;
  572.  
  573.     MOS_disp(OFF);
  574.     putstr((tp == NULL ? "":tp->buf),PAGE,(MAX_Y*16+now_ofs+slow_ofs)&511);
  575.     slow_ofs += 16;
  576.     scrool_bar_disp();
  577.     MOS_disp(ON);
  578.  
  579.     return FALSE;
  580. }
  581. static    int    FILE_one_down(void)
  582. {
  583.     if ( now_ptr == NULL || now_ptr->back == NULL )
  584.     return ERR;
  585.  
  586.     now_line--;
  587.     old_line--;
  588.     now_ptr = now_ptr->back;
  589.  
  590.     MOS_disp(OFF);
  591.     putstr(now_ptr->buf,PAGE,(now_ofs+slow_ofs-16)&511);
  592.     slow_ofs -= 16;
  593.     scrool_bar_disp();
  594.     MOS_disp(ON);
  595.  
  596.     return FALSE;
  597. }
  598. static    void    FILE_offset(int ofs)
  599. {
  600.     int n;
  601.  
  602.     while ( ofs > 0 ) {
  603.     while ( slow_ofs <= 0 ) {
  604.         if ( FILE_one_up() )
  605.         return;
  606.     }
  607.     n = (ofs < slow_ofs ? ofs : slow_ofs);
  608.     now_ofs = (now_ofs + n) & 511;
  609.     DSP_offset(1, 0, (now_ofs - SCRN_Y) & 511);
  610.     slow_ofs -= n;
  611.     ofs -= n;
  612.     }
  613.  
  614.     while ( ofs < 0 ) {
  615.     while ( slow_ofs >= 0 ) {
  616.         if ( FILE_one_down() )
  617.         return;
  618.     }
  619.     n = (-ofs < -slow_ofs ? -ofs : -slow_ofs);
  620.     now_ofs = (now_ofs - n) & 511;
  621.     DSP_offset(1, 0, (now_ofs - SCRN_Y) & 511);
  622.     slow_ofs += n;
  623.     ofs += n;
  624.     }
  625. }
  626. void    FILE_stop()
  627. {
  628.     int n;
  629.  
  630.     while ( scr_speed != 0 ) {
  631.     if ( (n = tick_timer - old_timer) != 0 ) {
  632.         old_timer = tick_timer;
  633.         if ( n < 0 )
  634.         n = 0 - n;
  635.         scr_speed /= 2;
  636.         if ( (n *= scr_speed) > 128 )
  637.         n = 128;
  638.         else if ( n < -128 )
  639.         n = -128;
  640.         FILE_offset(n);
  641.     }
  642.     }
  643.  
  644.     while ( 0 != slow_ofs ) {
  645.     if ( tick_timer != old_timer ) {
  646.         old_timer = tick_timer;
  647.         if ( slow_ofs > 0 )
  648.         FILE_offset(1);
  649.         else
  650.         FILE_offset(-1);
  651.     }
  652.     }
  653. }
  654. void    FILE_irq(void)
  655. {
  656.     int i, n, rc, fg;
  657.     int sw, x, y, sx, sy;
  658.     int of, nk1, nk2, oy1, oy2;
  659.  
  660.     if ( top_ptr == NULL )
  661.     return;
  662.  
  663.     MOS_rdpos(&sw, &x, &y);
  664.  
  665.     if ( sw == 0 ) {
  666.     if ( scr_speed != 0 && (n = tick_timer - old_timer) != 0 ) {
  667.         if ( n < 0 )
  668.         n = 0 - n;
  669.         old_timer = tick_timer;
  670.         if ( (n *= scr_speed) > 128 )
  671.         n = 128;
  672.         else if ( n < -128 )
  673.         n = -128;
  674.         FILE_offset(n);
  675.     }
  676.     return;
  677.     }
  678.  
  679.     fg = rc = FALSE;
  680.     of = 0;
  681.     nk1 = nk2 = tick_timer;
  682.     oy1 = oy2 = y;
  683.     FILE_stop();
  684.  
  685.     if ( y >= SCRN_Y1 && y <= SCRN_Y2 ) {
  686.     DSP_mos(1);
  687.     while ( sw != 0 ) {
  688.         MOS_rdpos(&sw, &sx, &sy);
  689.         if ( cut_mode != FALSE && y >= SCRN_Y && sw != 0 &&
  690.          ((sx - x) >= 16 || fg != FALSE) ) {
  691.         rc = CLIP_box(sw == 1 ? 0:1,
  692.                   x / 8,(y - SCRN_Y) / 16,(sx - x) / 8);
  693.         if ( rc != FALSE )
  694.             fg = TRUE;
  695.         }
  696.  
  697.         if ( fg != FALSE )
  698.         continue;
  699.  
  700.         if ( sw == 0 ) {            /* end of */
  701.         if ( (n = tick_timer - nk2) > 0 && n < 100 )
  702.             scr_speed = (oy2 - sy) / n;
  703.         else
  704.             scr_speed = 0;
  705.         old_timer = tick_timer;
  706.         break;
  707.  
  708.         } else if ( cut_mode != FALSE ) {
  709.         if ( (n = y - sy) <= -16 || n >= 16 && n != of ) {
  710.             FILE_offset(n - of);
  711.             of = n;
  712.         }
  713.         } else if ( (n = y - sy) != of ) {
  714.         FILE_offset(n - of);
  715.         of = n;
  716.         }
  717.  
  718.         if ( nk1 != tick_timer ) {
  719.         oy2 = oy1;
  720.         nk2 = nk1;
  721.         oy1 = sy;
  722.         nk1 = tick_timer;
  723.         }
  724.     }
  725.     DSP_mos(0);
  726.  
  727.     } else if ( x >= BAR_X1 && x <= BAR_X2 &&
  728.          y >= BAR_Y1 && y <= BAR_Y2 ) {
  729.     DSP_mos(1);
  730.     MOS_horizon(BAR_X1,BAR_X2);
  731.     MOS_vertical(BAR_Y1,BAR_Y2-8);
  732.     do {
  733.         FILE_disp((x - BAR_X1) * max_line / BAR_SIZ);
  734.         MOS_rdpos(&sw,&x,&y);
  735.     } while ( sw != 0 );
  736.     MOS_horizon(0,632);
  737.     MOS_vertical(0,470);
  738.     DSP_mos(0);
  739.     }
  740. }
  741. /****************************
  742. static int    LPT_putc(char ch,FILE *fp)
  743. {
  744.     for ( ; ; ) {
  745.     putc(ch,fp);
  746.     if ( !ferror(fp) )
  747.         break;
  748.     if ( pause("プリンタ出力にエラ－が発生しました！") == ERR )
  749.         return ERR;
  750.     clearerr(fp);
  751.     }
  752.     return FALSE;
  753. }
  754. void    FILE_lpt(void)
  755. {
  756.     int     n,ln;
  757.     LINPTR  *lp;
  758.     FILE    *fp;
  759.     char    *p;
  760.  
  761.     if ( top_ptr == NULL )
  762.     return;
  763.  
  764.     if ( yesno("表示している文書をプリンタに出力しますか？") == ERR )
  765.     return;
  766.  
  767.     if ( (fp = fopen("PRN","w")) == NULL ) {
  768.     kakunin("プリンタ出力がオ－プン出来ません");
  769.     return;
  770.     }
  771.  
  772.     BREAK_open("プリンタに出力しています ちょっと待ってね");
  773.  
  774.     n = ln = 0;
  775.     for ( lp = top_ptr ; lp != NULL ; lp = lp->next ) {
  776.     for ( p = lp->buf ; *p != '\0' ; p++ ) {
  777.         if ( LPT_putc(*p,fp) )
  778.         goto ENDOF;
  779.     }
  780.     if ( LPT_putc('\r',fp) || LPT_putc('\n',fp) )
  781.         goto ENDOF;
  782.     if ( ++ln >= LPT_LINE ) {
  783.         if ( LPT_putc('\x0C',fp) )
  784.         goto ENDOF;
  785.         ln = 0;
  786.     }
  787.     if ( BREAK_chk(max_line,++n) )
  788.         break;
  789.     }
  790.     if ( ln > 0 )
  791.     LPT_putc('\x0C',fp);
  792.  
  793. ENDOF:
  794.     fclose(fp);
  795.     BREAK_close();
  796. }
  797. *****************************************/
  798.  
  799. void    FILE_lpt(void)
  800. {
  801.     int     n;
  802.     LINPTR  *lp;
  803.  
  804.     if ( top_ptr == NULL )
  805.     return;
  806.  
  807. /*********
  808.     if ( yesno("Are You Sure ?") == ERR )
  809.     return;
  810. **********/
  811.  
  812.     if ( LPT_open() == ERR )
  813.     return;
  814.  
  815.     BREAK_open("Working.....");
  816.  
  817.     n = 0;
  818.     for ( lp = top_ptr ; lp != NULL ; lp = lp->next ) {
  819.     if ( PRN_puts(lp->buf) )
  820.         goto ENDOF;
  821.     if ( BREAK_chk(max_line,++n) )
  822.         break;
  823.     }
  824.     PRN_close();
  825.  
  826. ENDOF:
  827.     BREAK_close();
  828. }
  829.  
  830. int    iskan(char *p)
  831. {
  832.     if ( iskanji(*p) && iskanji2(*(p+1)) )
  833.     return TRUE;
  834.     else
  835.     return FALSE;
  836. }
  837. int    kan_pos(char *p,int n)
  838. {
  839.     int     i;
  840.  
  841.     for ( i = n ; i > 0 ; ) {
  842.     if ( *p == '\0' ) {
  843.         return (n - i);
  844.  
  845.     } else if ( iskan(p) ) {
  846.         i -= 2;
  847.         p += 2;
  848.  
  849.     } else {
  850.         i--;
  851.         p++;
  852.     }
  853.     }
  854.     return (n + i);
  855. }
  856.  
  857. int    input(int x,int y,int max,char *str)
  858. {
  859.     int     i,n,ch,cd;
  860.     int     ofs=0,len=0,pos=0;
  861.     BLOCK   *sp;
  862.     char    *p;
  863.     char    tmp[256];
  864.  
  865.     INKEY_start();
  866.     pos = len = strlen(str);
  867.  
  868.     memset(tmp,' ',max);
  869.     tmp[max] = '\0';
  870.     gputs(x,y,CHR_COL,WIND_COL,tmp);
  871.  
  872.     for ( ch = 0 ; ; ) {
  873.     ofs = 0;
  874.     n = pos;
  875.     while ( n >= (max - 4) ) {
  876.         ofs += (max / 2);
  877.         ofs = kan_pos(str,ofs);
  878.         n = pos - ofs;
  879.     }
  880.  
  881.     if ( (i = len - ofs) >= max )
  882.         i = kan_pos(str,ofs+max) - ofs;
  883.  
  884.     strncpy(tmp,&(str[ofs]),i);
  885.     tmp[i] = '\0';
  886.  
  887.         sp = DSP_push_vram(x,y,x+(i+3)*8,y+15);
  888.         gputs(x,y,CHR_COL,WIND_COL,tmp);
  889.     DSP_box(x+n*8,y+14,x+n*8+7,y+15,13,M_XOR);
  890.  
  891.     cur_x = x + n * 8;
  892.     cur_y = y;
  893.  
  894.     while ( (ch = getch()) == EOF );
  895.  
  896.     do {
  897.  
  898.         if ( ch == 0x08 && pos > 0 ) {
  899.         pos = kan_pos(str,pos-1);
  900.         p = &(str[pos]);
  901.         n = (iskan(p) ? 2:1);
  902.         strcpy(p,p+n);
  903.         len -= n;
  904.  
  905.         } else if ( ch == 0x7F ) {
  906.         if ( pos < len ) {
  907.             p = &(str[pos]);
  908.             n = (iskan(p) ? 2:1);
  909.             strcpy(p,p+n);
  910.             len -= n;
  911.         }
  912.  
  913.         } else if ( ch == 0x1C ) {
  914.         if ( pos < len )
  915.             pos += (iskan(&(str[pos])) ? 2:1);
  916.  
  917.         } else if ( ch == 0x1D ) {
  918.         if ( pos > 0 )
  919.             pos = kan_pos(str,pos-1);
  920.  
  921.         } else if ( ch >= ' ' && len < 128 ) {
  922.         if ( pos < len ) {
  923.             p = &(str[len]);
  924.             for ( i = len - pos ; i > 0 ; i--,p-- )
  925.             *p = *(p-1);
  926.         }
  927.         str[pos++] = ch;
  928.         len++;
  929.  
  930.         } else if ( ch == 0x0D ) {
  931.         cd = FALSE;
  932.         goto ENDOF;
  933.         } else if ( ch == 0x1B ) {
  934.         cd = ERR;
  935.         goto ENDOF;
  936.         }
  937.  
  938.     } while ( (ch = getch()) != EOF );
  939.  
  940.         DSP_pop_vram(sp);
  941.     }
  942.  
  943. ENDOF:
  944.     DSP_pop_vram(sp);
  945.     str[len] = '\0';
  946.     INKEY_end();
  947.     if ( (i = len) >= max )
  948.      i = kan_pos(str,max);
  949.     strncpy(tmp,&(str[ofs]),i);
  950.     tmp[i] = '\0';
  951.     gputs(x,y,CHR_COL,WIND_COL,tmp);
  952.  
  953.     return cd;
  954. }
  955. int    CLIP_box(box,cx,cy,len)
  956. int    box,cx,cy,len;
  957. {
  958.     int     i,n;
  959.     int     cut_x1,cut_y1,cut_x2,cut_y2;
  960.     LINPTR  *tp;
  961.  
  962.     tp = now_ptr;
  963.     for ( i = 0 ; tp != NULL && i < cy ; i++ )
  964.         tp = tp->next;
  965.  
  966.     if ( tp == NULL )
  967.     return FALSE;
  968.  
  969.     for ( i = 0 ; tp->buf[i] != '\0' && i < cx ; i++ ) {
  970.     if ( iskan(&(tp->buf[i])) ) {
  971.         if ( (i + 1) >= cx )
  972.         break;
  973.         i++;
  974.     }
  975.     }
  976.     cx = i;
  977.  
  978.     for ( n = 0 ; tp->buf[i] != '\0' && n < len ; ) {
  979.     if ( iskan(&(tp->buf[i])) ) {
  980.         cut_buf[box][n++] = tp->buf[i++];
  981.         cut_buf[box][n++] = tp->buf[i++];
  982.     } else {
  983.         cut_buf[box][n++] = tp->buf[i++];
  984.     }
  985.     }
  986.     cut_buf[box][n] = '\0';
  987.  
  988.     if ( (len = n) == 0 )
  989.     return FALSE;
  990.  
  991.     MOS_disp(OFF);
  992.     DSP_page(1);
  993.     cut_x1 = cx * 8;
  994.     cut_y1 = (cy * 16 + now_ofs + slow_ofs) & 511;
  995.     cut_x2 = (cx + len) * 8 - 1;
  996.     cut_y2 = (cy * 16 + 15 + now_ofs + slow_ofs) & 511;
  997.     DSP_vsync();
  998.     DSP_box(cut_x1,cut_y1,cut_x2,cut_y2,8,M_XOR);
  999.     DSP_vsync();
  1000.     DSP_box(cut_x1,cut_y1,cut_x2,cut_y2,8,M_XOR);
  1001.     DSP_page(0);
  1002.     MOS_disp(ON);
  1003.  
  1004.     return TRUE;
  1005. }
  1006. /********************************************************************
  1007.  
  1008.     COPY Funcsion
  1009.  
  1010. *********************************************************************/
  1011.  
  1012. static int    dir_make(char *file)
  1013. {
  1014.     char    *p;
  1015.  
  1016.     if ( (p = strchr(file,'\\')) != NULL ) {
  1017.     *p = '\0';
  1018.     if ( chdir(file) ) {
  1019.         if ( mkdir(file) ) {
  1020.         kakunin("ディレクトリの作成に失敗しました");
  1021.         return ERR;
  1022.         } else if ( chdir(file) ) {
  1023.         kakunin("ディレクトリの移動に失敗しました");
  1024.         return ERR;
  1025.         }
  1026.     }
  1027.     *p = '\\';
  1028.     dir_make(p+1);
  1029.     chdir("..");
  1030.     }
  1031.     return FALSE;
  1032. }
  1033. static int    copy(char *src,char *dis)
  1034. {
  1035.     int     cd,i,n;
  1036.     long    fs;
  1037.     FILE    *ifp,*ofp;
  1038.     char    *p;
  1039.     char    tmp[4096];
  1040.  
  1041.     if ( (ifp = fopen(dis,"rb")) != NULL ) {
  1042.     fclose(ifp);
  1043.     if ( yesno("%sが存在しますｺﾋﾟ-を行いますか？",dis) == ERR )
  1044.         return TRUE;
  1045.     }
  1046.  
  1047.     if ( dir_make(dis) == ERR )
  1048.     return ERR;
  1049.  
  1050.     if ( (ifp = fopen(src,"rb")) == NULL ) {
  1051.     kakunin("%sﾌｧｲﾙがオ－プンできません",src);
  1052.     return ERR;
  1053.     }
  1054.  
  1055.     if ( (ofp = fopen(dis,"wb")) == NULL ) {
  1056.     fclose(ifp);
  1057.     kakunin("%sﾌｧｲﾙがオ－プンできません",dis);
  1058.     return ERR;
  1059.     }
  1060.  
  1061.     cd = FALSE;
  1062.     n = 0;
  1063.     fseek(ifp,0L,SEEK_END);
  1064.     fs = ftell(ifp);
  1065.     rewind(ifp);
  1066.  
  1067.     if ( (p = strrchr(dis,'\\')) != NULL )
  1068.     p++;
  1069.     else
  1070.     p = dis;
  1071.     BREAK_open("Making a copy %s", p);
  1072.  
  1073.     while ( (i = fread(tmp,1,4096,ifp)) > 0 ) {
  1074.     fwrite(tmp,1,i,ofp);
  1075.     n += i;
  1076.     if ( ferror(ifp) || ferror(ofp) ) {
  1077.         kakunin("ファイルコピ－にエラ－が発生しました");
  1078.         cd = ERR;
  1079.         break;
  1080.     }
  1081.     if ( BREAK_chk(fs,n) ) {
  1082.         cd = ERR;
  1083.         break;
  1084.     }
  1085.     }
  1086.  
  1087.     fclose(ifp);
  1088.     fclose(ofp);
  1089.     if ( cd == ERR )
  1090.     remove(dis);
  1091.     BREAK_close();
  1092.  
  1093.     return cd;
  1094. }
  1095. static    int    cmds_xcopy(char *home,char *src,char *dis)
  1096. {
  1097.     int     n;
  1098.     int     cd;
  1099.     int     wd=FALSE;
  1100.     DIR     *dirp;
  1101.     DIRECT  *dp;
  1102.     char    *p;
  1103.     char    tmp[128];
  1104.     char    dmy[128];
  1105.  
  1106.     if ( src == NULL || *src == '\0' )
  1107.     src = "*.*";
  1108.  
  1109.     if ( src[1] != ':' && home != NULL ) {
  1110.     strcpy(tmp,home);
  1111.     joint_path(tmp,src);
  1112.     } else
  1113.     strcpy(tmp,src);
  1114.  
  1115.     for ( p = tmp ; *p != '\0' ; p++ );
  1116.  
  1117.     if ( strchr(tmp,'*') != NULL || strchr(tmp,'?') )
  1118.     wd = TRUE;
  1119.     else if ( (p != tmp && *(p-1) == '\\') || isdir(tmp) ) {
  1120.     joint_path(tmp,"*.*");
  1121.     wd = TRUE;
  1122.     }
  1123.  
  1124.     DSP_mos(2);
  1125.     dirp = opendir(tmp);
  1126.     DSP_mos(0);
  1127.  
  1128.     if ( dirp == NULL ) {
  1129.     kakunin("%sファイルが見当たりません",tmp);
  1130.     return ERR;
  1131.     }
  1132.  
  1133.     if ( (src = strrchr(tmp,'\\')) != NULL ||
  1134.      (src = strrchr(tmp,':')) != NULL )
  1135.     src++;
  1136.     else
  1137.     src = tmp;
  1138.  
  1139.     if ( dis == NULL )
  1140.     dis = "";
  1141.  
  1142.     strcpy(dmy,dis);
  1143.  
  1144.     for ( n = 0 ; dmy[n] != '\0' ; n++ );
  1145.     if ( n == 0 || dmy[n-1] == '\\' || dmy[n-1] == ':' )
  1146.      wd = TRUE;
  1147.  
  1148.     if ( wd != FALSE ) {
  1149.     for ( n = 0 ; dmy[n] != '\0' ; n++ );
  1150.     if ( n > 0 && dmy[n-1] != '\\' && dmy[n-1] != ':' )
  1151.         strcat(dmy,"\\");
  1152.     dis = dmy;
  1153.     while ( *dis != '\0' ) dis++;
  1154.     }
  1155.  
  1156.     while ( (dp = readdir(dirp)) != NULL ) {
  1157.     if ( !IS_DIR(dp) ) {
  1158.  
  1159.         strcpy(src,dp->d_name);
  1160.  
  1161.         if ( wd != FALSE )
  1162.         strcpy(dis,dp->d_name);
  1163.  
  1164.         while ( (cd = copy(tmp,dmy)) == ERR ) {
  1165.         if ( pause("コピ－を続行しますか？") == ERR )
  1166.             goto ENDOF;
  1167.         }
  1168.     } else if ( strcmp(dp->d_name,".") != 0 &&
  1169.             strcmp(dp->d_name,"..") != 0 ) {
  1170.         strcpy(src,dp->d_name);
  1171.         if ( wd != FALSE )
  1172.         strcpy(dis,dp->d_name);
  1173.         if ( cmds_xcopy(home,tmp,dmy) ) {
  1174.         if ( pause("コピ－を続行しますか？") == ERR )
  1175.             goto ENDOF;
  1176.         }
  1177.     }
  1178.     }
  1179.  
  1180. ENDOF:
  1181.     closedir(dirp);
  1182.     return (cd == ERR ? ERR:FALSE);
  1183. }
  1184. static    int    cmds_copy(char *home,char *src,char *dis)
  1185. {
  1186.     int     n;
  1187.     int     cd;
  1188.     int     wd=FALSE;
  1189.     DIR     *dirp;
  1190.     DIRECT  *dp;
  1191.     char    *p;
  1192.     char    tmp[128];
  1193.     char    dmy[128];
  1194.  
  1195.     if ( src == NULL || *src == '\0' )
  1196.     src = "*.*";
  1197.  
  1198.     if ( src[1] != ':' && home != NULL ) {
  1199.     strcpy(tmp,home);
  1200.     joint_path(tmp,src);
  1201.     } else
  1202.     strcpy(tmp,src);
  1203.  
  1204.     for ( p = tmp ; *p != '\0' ; p++ );
  1205.  
  1206.     if ( strchr(tmp,'*') != NULL || strchr(tmp,'?') )
  1207.     wd = TRUE;
  1208.     else if ( (p != tmp && *(p-1) == '\\') || isdir(tmp) ) {
  1209.     joint_path(tmp,"*.*");
  1210.     wd = TRUE;
  1211.     }
  1212.  
  1213.     DSP_mos(2);
  1214.     dirp = opendir(tmp);
  1215.     DSP_mos(0);
  1216.  
  1217.     if ( dirp == NULL ) {
  1218.     kakunin("%sファイルが見当たりません",tmp);
  1219.     return ERR;
  1220.     }
  1221.  
  1222.     if ( (src = strrchr(tmp,'\\')) != NULL ||
  1223.      (src = strrchr(tmp,':')) != NULL )
  1224.     src++;
  1225.     else
  1226.     src = tmp;
  1227.  
  1228.     if ( dis == NULL )
  1229.     dis = "";
  1230.  
  1231.     strcpy(dmy,dis);
  1232.  
  1233.     for ( n = 0 ; dmy[n] != '\0' ; n++ );
  1234.     if ( n == 0 || dmy[n-1] == '\\' || dmy[n-1] == ':' )
  1235.      wd = TRUE;
  1236.  
  1237.     if ( wd != FALSE ) {
  1238.     for ( n = 0 ; dmy[n] != '\0' ; n++ );
  1239.     if ( n > 0 && dmy[n-1] != '\\' && dmy[n-1] != ':' )
  1240.         strcat(dmy,"\\");
  1241.     dis = dmy;
  1242.     while ( *dis != '\0' ) dis++;
  1243.     }
  1244.  
  1245.     while ( (dp = readdir(dirp)) != NULL ) {
  1246.     if ( !IS_DIR(dp) ) {
  1247.  
  1248.         strcpy(src,dp->d_name);
  1249.  
  1250.         if ( wd != FALSE )
  1251.         strcpy(dis,dp->d_name);
  1252.  
  1253.         while ( (cd = copy(tmp,dmy)) == ERR ) {
  1254.         if ( pause("コピ－を続行しますか？") == ERR )
  1255.             goto ENDOF;
  1256.         }
  1257.     }
  1258.     }
  1259.  
  1260. ENDOF:
  1261.     closedir(dirp);
  1262.     return (cd == ERR ? ERR:FALSE);
  1263. }
  1264. static    int    cmds_rename(char *src,char *dis)
  1265. {
  1266.     if ( src[0] != '\0' && src[1] == ':' ) {
  1267.     kakunin("絶対パスでのファイル名変更はできません");
  1268.     return ERR;
  1269.     }
  1270.  
  1271.     if ( rename(src,dis) ) {
  1272.     kakunin("ファイル名の変更ができませんでした");
  1273.     return ERR;
  1274.     }
  1275.     return FALSE;
  1276. }
  1277. static    int    cmds_mkdir(char *dir)
  1278. {
  1279.     if ( dir[0] != '\0' && dir[1] == ':' ) {
  1280.     kakunin("絶対パスでのディレクトリ作成はできません");
  1281.     return ERR;
  1282.     }
  1283.  
  1284.     if ( mkdir(dir) ) {
  1285.     kakunin("ディレクトリの作成ができませんでした");
  1286.     return ERR;
  1287.     }
  1288.     return FALSE;
  1289. }
  1290. static    int    cmds_chdir(char *dir)
  1291. {
  1292.     if ( dir[0] != '\0' && dir[1] == ':' ) {
  1293.     kakunin("絶対パスでのディレクトリ移動はできません");
  1294.     return ERR;
  1295.     }
  1296.  
  1297.     if ( chdir(dir) ) {
  1298.     kakunin("ディレクトリの移動ができませんでした");
  1299.     return ERR;
  1300.     }
  1301.     return FALSE;
  1302. }
  1303. static    int    cmdstr(char *src,char *ptn)
  1304. {
  1305.     while ( *ptn != '\0' ) {
  1306.     if ( toupper(*src) != *ptn )
  1307.         return FALSE;
  1308.     src++;
  1309.     ptn++;
  1310.     }
  1311.     if ( *src == '\0' || isspace(*src) )
  1312.     return TRUE;
  1313.     else
  1314.     return FALSE;
  1315. }
  1316.  
  1317. #define    ST_EOF        0
  1318. #define    ST_ELSE        1
  1319. #define    ST_ENDIF    2
  1320.  
  1321. static    char    cmds_dmy[BUFSIZ];
  1322. static    char    cmds_home[BUFSIZ];
  1323.  
  1324. static    int    cmds_line(LINPTR **fp,int rc)
  1325. {
  1326.     int     n;
  1327.     char    *p;
  1328.     char    *s;
  1329.     char    *r;
  1330.  
  1331.     while ( (*fp)->next != NULL ) {
  1332.     (*fp) = (*fp)->next;
  1333.     p = (*fp)->buf;
  1334.  
  1335.     while ( isspace(*p) ) p++;
  1336.  
  1337.     if ( *p == '\0' || *p == '#' )
  1338.         continue;
  1339.  
  1340.     if ( cmdstr(p,"IF") ) {
  1341.         if ( rc == FALSE ) {
  1342.         while ( (n = cmds_line(fp,FALSE)) == ST_ELSE );
  1343.         if ( n == ST_EOF )
  1344.             break;
  1345.  
  1346.         continue;
  1347.         }
  1348.  
  1349.         while ( !isspace(*p) && *p != '\0' ) p++;
  1350.         while ( isspace(*p) ) p++;
  1351.         if ( yesno2(p) == ERR ) {    /* else */
  1352.         if ( (n = cmds_line(fp,FALSE)) == ST_ELSE )
  1353.            n = cmds_line(fp,TRUE);
  1354.  
  1355.         } else {            /* then */
  1356.         if ( (n = cmds_line(fp,TRUE)) == ST_ELSE )
  1357.            n = cmds_line(fp,FALSE);
  1358.         }
  1359.         if ( n == ST_EOF )
  1360.         break;
  1361.  
  1362.         continue;
  1363.  
  1364.     } else if ( cmdstr(p,"ELSE") ) {
  1365.         return ST_ELSE;
  1366.  
  1367.     } else if ( cmdstr(p,"ENDIF") ) {
  1368.         return ST_ENDIF;
  1369.     }
  1370.  
  1371.     if ( rc == FALSE )
  1372.         continue;
  1373.  
  1374.     if ( cmdstr(p,"XCOPY") ) {
  1375.         while ( !isspace(*p) && *p != '\0' ) p++;
  1376.         while ( isspace(*p) ) p++;
  1377.         s = p;
  1378.         while ( !isspace(*p) && *p != '\0' ) p++;
  1379.         if ( *p != '\0' ) *(p++) = '\0';
  1380.         while ( isspace(*p) ) p++;
  1381.         r = p;
  1382.         while ( !isspace(*r) && *r != '\0' ) r++;
  1383.         *r = '\0';
  1384.         if ( cmds_xcopy(cmds_home,s,p) )
  1385.         break;
  1386.  
  1387.     } else if ( cmdstr(p,"COPY") ) {
  1388.         while ( !isspace(*p) && *p != '\0' ) p++;
  1389.         while ( isspace(*p) ) p++;
  1390.         s = p;
  1391.         while ( !isspace(*p) && *p != '\0' ) p++;
  1392.         if ( *p != '\0' ) *(p++) = '\0';
  1393.         while ( isspace(*p) ) p++;
  1394.         r = p;
  1395.         while ( !isspace(*r) && *r != '\0' ) r++;
  1396.         *r = '\0';
  1397.         if ( cmds_copy(cmds_home,s,p) )
  1398.         break;
  1399.  
  1400.     } else if ( cmdstr(p,"RENAME") ) {
  1401.         while ( !isspace(*p) && *p != '\0' ) p++;
  1402.         while ( isspace(*p) ) p++;
  1403.         s = p;
  1404.         while ( !isspace(*p) && *p != '\0' ) p++;
  1405.         if ( *p != '\0' ) *(p++) = '\0';
  1406.         while ( isspace(*p) ) p++;
  1407.         r = p;
  1408.         while ( !isspace(*r) && *r != '\0' ) r++;
  1409.         *r = '\0';
  1410.         if ( cmds_rename(s,p) )
  1411.         break;
  1412.  
  1413.     } else if ( cmdstr(p,"MKDIR") ) {
  1414.         while ( !isspace(*p) && *p != '\0' ) p++;
  1415.         while ( isspace(*p) ) p++;
  1416.         r = p;
  1417.         while ( !isspace(*r) && *r != '\0' ) r++;
  1418.         *r = '\0';
  1419.         if ( cmds_mkdir(p) )
  1420.         break;
  1421.  
  1422.     } else if ( cmdstr(p,"CHDIR") ) {
  1423.         while ( !isspace(*p) && *p != '\0' ) p++;
  1424.         while ( isspace(*p) ) p++;
  1425.         r = p;
  1426.         while ( !isspace(*r) && *r != '\0' ) r++;
  1427.         *r = '\0';
  1428.         if ( cmds_chdir(p) )
  1429.         break;
  1430.  
  1431.     } else if ( cmdstr(p,"PAUSE") ) {
  1432.         while ( !isspace(*p) && *p != '\0' ) p++;
  1433.         while ( isspace(*p) ) p++;
  1434.         if ( pause(p) == ERR )
  1435.         break;
  1436.  
  1437.     } else if ( cmdstr(p,"INST") ) {
  1438.         while ( !isspace(*p) && *p != '\0' ) p++;
  1439.         while ( isspace(*p) ) p++;
  1440.         r = p;
  1441.         while ( !isspace(*r) && *r != '\0' ) r++;
  1442.         *r = '\0';
  1443.         strcpy(cmds_dmy,cmds_home);
  1444.         joint_path(cmds_dmy,p);
  1445.         if ( CMDS_file(cmds_dmy) )
  1446.         break;
  1447.  
  1448.     } else if ( cmdstr(p,"LOOK") ) {
  1449.         while ( !isspace(*p) && *p != '\0' ) p++;
  1450.         while ( isspace(*p) ) p++;
  1451.         r = p;
  1452.         while ( !isspace(*r) && *r != '\0' ) r++;
  1453.         *r = '\0';
  1454.         strcpy(cmds_dmy,cmds_home);
  1455.         joint_path(cmds_dmy,p);
  1456.         if ( !JOKE_run(cmds_dmy, FALSE) )
  1457.         break;
  1458.  
  1459.     } else if ( cmdstr(p,"PLAY") ) {
  1460.         while ( !isspace(*p) && *p != '\0' ) p++;
  1461.         while ( isspace(*p) ) p++;
  1462.         r = p;
  1463.         while ( !isspace(*r) && *r != '\0' ) r++;
  1464.         *r = '\0';
  1465.         if ( cmdstr(p,"STOP") ) {
  1466.         END_eup();
  1467.         } else {
  1468.             strcpy(cmds_dmy,cmds_home);
  1469.             joint_path(cmds_dmy,p);
  1470.             PLAY_eup(cmds_dmy);
  1471.         }
  1472.  
  1473.     } else if ( cmdstr(p,"PUSH") ) {
  1474.         SCRN_saver(1);
  1475.  
  1476.     } else if ( cmdstr(p,"POP") ) {
  1477.         SCRN_saver(0);
  1478.  
  1479.     } else if ( cmdstr(p,"EXIT") ) {
  1480.         break;
  1481.  
  1482.     }
  1483.     }
  1484.  
  1485.     return ST_EOF;
  1486. }
  1487. int    CMDS_file(char *file)
  1488. {
  1489.     int     n;
  1490.     LINPTR  tp;
  1491.     LINPTR  *fp;
  1492.     char    *p;
  1493.     char    home[BUFSIZ];
  1494.  
  1495.     n = max_line;
  1496.     if ( (tp.next = read_file(file)) == NULL ) {
  1497.     kakunin("'%s'コマンドが見当たりません",file);
  1498.     return ERR;
  1499.     }
  1500.     max_line = n;
  1501.  
  1502.     strcpy(home,cmds_home);
  1503.     strcpy(cmds_home,file);
  1504.     if ( (p = strrchr(cmds_home,'\\')) == NULL )
  1505.     p = cmds_home;
  1506.     *p = '\0';
  1507.  
  1508.     fp = &tp;
  1509.     cmds_line(&fp,TRUE);
  1510.  
  1511.     strcpy(cmds_home,home);
  1512.     free_file(tp.next);
  1513.     return FALSE;
  1514. }
  1515.  
  1516. static    unsigned long    fcopy_max = 0;
  1517. static    unsigned long    fcopy_pos = 0;
  1518.  
  1519. static int    fcopy(char *src, char *dis, long sz)
  1520. {
  1521.     int     cd,i,n;
  1522.     long    fs;
  1523.     FILE    *ifp,*ofp;
  1524.     char    *p;
  1525.     char    tmp[4096];
  1526.  
  1527.     if ( (ifp = fopen(dis,"rb")) != NULL ) {
  1528.     fclose(ifp);
  1529.     if ( yesno("%sが存在しますｺﾋﾟ-を行いますか？",dis) == ERR )
  1530.         return TRUE;
  1531.     }
  1532.  
  1533.     if ( dir_make(dis) == ERR )
  1534.     return ERR;
  1535.  
  1536.     if ( (ifp = fopen(src,"rb")) == NULL ) {
  1537.     kakunin("%sﾌｧｲﾙがオ－プンできません",src);
  1538.     return ERR;
  1539.     }
  1540.  
  1541.     if ( (ofp = fopen(dis,"wb")) == NULL ) {
  1542.     fclose(ifp);
  1543.     kakunin("%sﾌｧｲﾙがオ－プンできません",dis);
  1544.     return ERR;
  1545.     }
  1546.  
  1547.     cd = FALSE;
  1548.  
  1549.     if ( (p = strrchr(dis,'\\')) != NULL )
  1550.     p++;
  1551.     else
  1552.     p = dis;
  1553.  
  1554.     BREAK_open("%4dK/%4dK+%4dK %-12.12s",
  1555.         fcopy_pos / 1000, fcopy_max / 1000, sz / 1000, p);
  1556.  
  1557.     fs = fcopy_pos;
  1558.     while ( (i = fread(tmp,1,4096,ifp)) > 0 ) {
  1559.     if ( fwrite(tmp, 1, i, ofp) != i )
  1560.         break;
  1561.     fs += i;
  1562.     if ( BREAK_chk(fcopy_max, fs) ) {
  1563.         cd = ERR;
  1564.         break;
  1565.     }
  1566.     }
  1567.  
  1568.     if ( ferror(ifp) || ferror(ofp) ) {
  1569.     kakunin("ファイルコピ－にエラ－が発生しました");
  1570.     cd = ERR;
  1571.     }
  1572.  
  1573.     fclose(ifp);
  1574.     fclose(ofp);
  1575.  
  1576.     if ( cd == ERR )
  1577.     remove(dis);
  1578.     else
  1579.     fcopy_pos = fs;
  1580.  
  1581.     return cd;
  1582. }
  1583. static int    wcopy(char *wild)
  1584. {
  1585.     int     cd = FALSE;
  1586.     long    sz;
  1587.     DIR     *dirp;
  1588.     DIRECT  *dp;
  1589.     char    *p;
  1590.     char    *src,*dis;
  1591.     char    tmp[256];
  1592.  
  1593.     if ( (dirp = opendir(wild)) == NULL )
  1594.     return ERR;
  1595.  
  1596.     strcpy(tmp,wild);
  1597.     if ( (p = strrchr(tmp,'\\')) != NULL )
  1598.     p++;
  1599.     else
  1600.     p = tmp;
  1601.  
  1602.     while ( (dp = readdir(dirp)) != NULL ) {
  1603.     if ( !IS_DIR(dp) ) {
  1604.  
  1605.         strcpy(p,dp->d_name);
  1606.         src = tmp;
  1607.         dis = dp->d_name;
  1608.  
  1609.         while ( (cd = fcopy(src, dis, dp->d_size)) == ERR ) {
  1610.         if ( yesno("コピ－を続行しますか？") == ERR )
  1611.             goto ENDOF;
  1612.         }
  1613.  
  1614.     } else if ( dp->d_name[0] != '.' ) {
  1615.         strcpy(p,dp->d_name);
  1616.         strcat(tmp, "\\*.*");
  1617.         sz = sizedir(tmp);
  1618.  
  1619.         if ( yesno("%s(%ldK)ディレクトリもコピ－しますか？",
  1620.             dp->d_name, sz / 1000) == ERR )
  1621.         continue;
  1622.  
  1623.         if ( chdir(dp->d_name) ) {
  1624.         if ( mkdir(dp->d_name) ) {
  1625.             kakunin("サブディレクトリの作成に失敗しました");
  1626.             continue;
  1627.         } else if ( chdir(dp->d_name) ) {
  1628.             kakunin("サブディレクトリへの移動に失敗しました");
  1629.             continue;
  1630.         }
  1631.         }
  1632.  
  1633.         fcopy_max += sz;
  1634.  
  1635.         if ( (cd = wcopy(tmp)) == ERR )
  1636.         goto ENDOF;
  1637.  
  1638.         chdir("..");
  1639.     }
  1640.     }
  1641.  
  1642. ENDOF:
  1643.     closedir(dirp);
  1644.     return cd;
  1645. }
  1646. static    int    zcopy(int ac, char *av[])
  1647. {
  1648.     int n;
  1649.     char *p;
  1650.     unsigned long fr, ta;
  1651.  
  1652.     DSP_mos(2);
  1653.     fcopy_max = fcopy_pos = 0;
  1654.     for ( n = 0 ; n < ac ; n++ ) {
  1655.     if ( (p = strrchr(av[n], '.')) != NULL && strcmp(p,".QQQ") == 0 ) {
  1656.         if ( CMDS_file(av[n]) ) {
  1657.         DSP_mos(0);
  1658.         return ERR;
  1659.         }
  1660.     } else
  1661.         fcopy_max += sizedir(av[n]);
  1662.     }
  1663.     DSP_mos(0);
  1664.  
  1665.     if ( !disk_free((-1), &fr, &ta) && (fcopy_max / 1024) > fr ) {
  1666.     if ( yesno("空き容量が足りませんコピ－を続行しますか？") == ERR )
  1667.         return ERR;
  1668.     }
  1669.  
  1670.     BREAK_open("Total %4dK", fcopy_max / 1000);
  1671.     for ( n = 0 ; n < ac ; n++ ) {
  1672.     if ( (p = strrchr(av[n], '.')) == NULL || strcmp(p,".QQQ") != 0 ) {
  1673.         if ( wcopy(av[n]) ) {
  1674.         BREAK_close();
  1675.             return ERR;
  1676.         }
  1677.     }
  1678.     }
  1679.     BREAK_close();
  1680.  
  1681.     return FALSE;
  1682. }
  1683.  
  1684. #define    CHDIR_X1    (11*8-4)
  1685. #define    CHDIR_Y1    150
  1686. #define    CHDIR_X2    (68*8+3)
  1687. #define    CHDIR_Y2    340
  1688.  
  1689. #define    CHDIR_MSG_X    ((CHDIR_X1+CHDIR_X2)/2)
  1690. #define    CHDIR_MSG_Y    (CHDIR_Y1+30)
  1691.  
  1692. #define    CHDIR_TTL_X    (CHDIR_X1+3*8)
  1693.  
  1694. #define    CHDIR_BACK_X    (CHDIR_X1+17*8)
  1695. #define    CHDIR_BACK_Y    (CHDIR_Y1+70)
  1696.  
  1697. #define    CHDIR_BACK_X1    (CHDIR_BACK_X-4)
  1698. #define    CHDIR_BACK_Y1    (CHDIR_BACK_Y-9)
  1699. #define    CHDIR_BACK_X2    (CHDIR_BACK_X+2*8+4)
  1700. #define    CHDIR_BACK_Y2    (CHDIR_BACK_Y1+33)
  1701.  
  1702. #define    CHDIR_DRIV_X    (CHDIR_X1+20*8)
  1703. #define    CHDIR_DRIV_Y    (CHDIR_Y1+61)
  1704.  
  1705. #define    CHDIR_DRIV_X1    (CHDIR_DRIV_X)
  1706. #define    CHDIR_DRIV_Y1    (CHDIR_DRIV_Y)
  1707. #define    CHDIR_DRIV_X2    (CHDIR_DRIV_X+33)
  1708. #define    CHDIR_DRIV_Y2    (CHDIR_DRIV_Y+33)
  1709.  
  1710. #define    CHDIR_NEXT_X    (CHDIR_X1+25*8+2)
  1711. #define    CHDIR_NEXT_Y    (CHDIR_Y1+70)
  1712.  
  1713. #define    CHDIR_NEXT_X1    (CHDIR_NEXT_X-4)
  1714. #define    CHDIR_NEXT_Y1    (CHDIR_NEXT_Y-9)
  1715. #define    CHDIR_NEXT_X2    (CHDIR_NEXT_X+2*8+4)
  1716. #define    CHDIR_NEXT_Y2    (CHDIR_NEXT_Y1+33)
  1717.  
  1718. #define    CHDIR_DIR_X    (CHDIR_X1+17*8)
  1719. #define    CHDIR_DIR_Y    (CHDIR_Y1+110)
  1720.  
  1721. #define    CHDIR_YES_X    ((CHDIR_X1+CHDIR_X2)/2-(10*8))
  1722. #define    CHDIR_YES_Y    (CHDIR_Y1+150)
  1723.  
  1724. #define    CHDIR_NO_X    ((CHDIR_X1+CHDIR_X2)/2+(2*8))
  1725. #define    CHDIR_NO_Y    (CHDIR_Y1+150)
  1726.  
  1727. #define    CHDIR_FREE_X    (CHDIR_X1+32*8)
  1728. #define    CHDIR_FREE_Y    (CHDIR_Y1+61)
  1729.  
  1730. void    COPY_all(int argc,char *argv[])
  1731. {
  1732.     int     n;
  1733.     int     now,fg;
  1734.     int     cd,sw,bx,by;
  1735.     BLOCK   *sp;
  1736.     EVENT   *ep=NULL;
  1737.     char    *p,*s;
  1738.     char    tmp[256];
  1739.     char    buf[32];
  1740.     unsigned long fr, ta;
  1741.  
  1742. /*********
  1743.     if ( yesno("Are You Sure ?") == ERR )
  1744.     return;
  1745. **********/
  1746.  
  1747.     MOS_disp(OFF);
  1748.     sp = DSP_push_vram(CHDIR_X1,CHDIR_Y1,CHDIR_X2,CHDIR_Y2);
  1749.     DSP_opbox(CHDIR_X1,CHDIR_Y1,CHDIR_X2,CHDIR_Y2);
  1750.     DSP_wbox(CHDIR_X1,CHDIR_Y1,CHDIR_X2,CHDIR_Y2,LINE_COL,FILD_COL,M_PSET);
  1751.  
  1752. /*******
  1753.     strcpy(tmp,"DRIVE & DIRECTORY SELECT");
  1754.     gputs(CHDIR_MSG_X-strlen(tmp)*4,CHDIR_MSG_Y,CHR_COL,FILD_COL,tmp);
  1755.     gputs(CHDIR_TTL_X,CHDIR_BACK_Y,CHR_COL,FILD_COL,"DRIVE");
  1756.     gputs(CHDIR_TTL_X,CHDIR_DIR_Y,CHR_COL,FILD_COL,"DIRECTORY");
  1757. ********/
  1758.  
  1759.     DSP_strimg(drive_select_img,
  1760.     CHDIR_MSG_X-86,CHDIR_MSG_Y+3,CHR_COL,FILD_COL,M_PSET);
  1761.     DSP_strimg(drive_img,
  1762.     CHDIR_TTL_X,CHDIR_BACK_Y+3,CHR_COL,FILD_COL,M_PSET);
  1763.     DSP_strimg(directory_img,
  1764.     CHDIR_TTL_X,CHDIR_DIR_Y+3,CHR_COL,FILD_COL,M_PSET);
  1765.  
  1766.     now = getdrv();
  1767.     DSP_wbox(CHDIR_BACK_X1,CHDIR_BACK_Y1,
  1768.          CHDIR_BACK_X2,CHDIR_BACK_Y2,LINE_COL,WIND_COL,M_PSET);
  1769.     gputs(CHDIR_BACK_X,CHDIR_BACK_Y,CHR_COL,WIND_COL,"＜");
  1770.     ep = EVT_set(ep,1,CHDIR_BACK_X1,CHDIR_BACK_Y1,
  1771.               CHDIR_BACK_X2,CHDIR_BACK_Y2,EVT_proc);
  1772.  
  1773.     ep = EVT_set(ep,2,CHDIR_DRIV_X1,CHDIR_DRIV_Y1,
  1774.               CHDIR_DRIV_X2,CHDIR_DRIV_Y2,EVT_proc);
  1775.  
  1776.     DSP_wbox(CHDIR_NEXT_X1,CHDIR_NEXT_Y1,
  1777.          CHDIR_NEXT_X2,CHDIR_NEXT_Y2,LINE_COL,WIND_COL,M_PSET);
  1778.     gputs(CHDIR_NEXT_X,CHDIR_NEXT_Y,CHR_COL,WIND_COL,"＞");
  1779.     ep = EVT_set(ep,3,CHDIR_NEXT_X1,CHDIR_NEXT_Y1,
  1780.               CHDIR_NEXT_X2,CHDIR_NEXT_Y2,EVT_proc);
  1781.  
  1782.     sprintf(tmp,"%-34.34s","？");
  1783.     ep = EVT_sw(ep,4,CHDIR_DIR_X,CHDIR_DIR_Y,CHR_COL,WIND_COL,tmp);
  1784.  
  1785. /***************
  1786.     ep = EVT_sw(ep,5,CHDIR_YES_X,CHDIR_YES_Y,CHR_COL,WIND_COL,"   OK   ");
  1787.     ep = EVT_sw(ep,6,CHDIR_NO_X,CHDIR_NO_Y,CHR_COL,WIND_COL,  " CANCEL ");
  1788. ****************/
  1789.     ep = EVT_img(ep,5,CHDIR_YES_X,CHDIR_YES_Y,CHR_COL,WIND_COL,64,ok_img);
  1790.     ep = EVT_img(ep,6,CHDIR_NO_X,CHDIR_NO_Y,CHR_COL,WIND_COL,  64,cancel_img);
  1791.  
  1792.     ICON_disp(CHDIR_DRIV_X,CHDIR_DRIV_Y,now);
  1793.  
  1794.     MOS_rdpos(&sw,&bx,&by);
  1795.     MOS_setpos((CHDIR_X1+CHDIR_X2)/2,(CHDIR_Y1+CHDIR_Y2)/2);
  1796.     MOS_disp(ON);
  1797.  
  1798.     tmp[0] = '\0';
  1799.     for ( cd = FALSE ; cd == FALSE ; ) {
  1800.     switch(EVT_wait(ep)) {
  1801.     case 1:
  1802.         do {
  1803.         if ( --now < 0 ) now = 25;
  1804.         } while ( drv_tbl[now] == IS_NON );
  1805.         MOS_disp(OFF);
  1806.         ICON_disp(CHDIR_DRIV_X,CHDIR_DRIV_Y,now);
  1807.         tmp[0] = '\0';
  1808.         gprintf(CHDIR_DIR_X,CHDIR_DIR_Y,CHR_COL,WIND_COL,"%-34.34s","？");
  1809.         DSP_box(CHDIR_FREE_X, CHDIR_FREE_Y,
  1810.             CHDIR_FREE_X + 93, CHDIR_FREE_Y + 33,
  1811.             FILD_COL, M_PSET);
  1812.         MOS_disp(ON);
  1813.         break;
  1814.  
  1815.     case 2:
  1816.         DSP_mos(2);
  1817.         if ( chdrv(now) || getdir(tmp) )
  1818.         tmp[0] = '\0';
  1819.         DSP_mos(0);
  1820.         MOS_disp(OFF);
  1821.         gprintf(CHDIR_DIR_X,CHDIR_DIR_Y,CHR_COL,WIND_COL,
  1822.             "%-34.34s",(tmp[0] == '\0' ? "？":tmp));
  1823.         if ( tmp[0] != '\0' && now != 16 &&
  1824.             !disk_free(now, &fr, &ta) ) {
  1825.         gprintf(CHDIR_FREE_X, CHDIR_FREE_Y, CHR_COL, FILD_COL,
  1826.             "%6dK", fr);
  1827.         gprintf(CHDIR_FREE_X, CHDIR_FREE_Y + 17, CHR_COL, FILD_COL,
  1828.             "%6dK", ta);
  1829.         n = fr * 29 / ta;
  1830.         DSP_wbox(CHDIR_FREE_X + 60, CHDIR_FREE_Y,
  1831.              CHDIR_FREE_X + 93, CHDIR_FREE_Y + 33,
  1832.              LINE_COL, WIND_COL, M_PSET);
  1833.         DSP_wbox(CHDIR_FREE_X + 62, CHDIR_FREE_Y + 2,
  1834.              CHDIR_FREE_X + 91, CHDIR_FREE_Y + 31,
  1835.              LINE_COL, FILD_COL, M_PSET);
  1836.         DSP_wbox(CHDIR_FREE_X + 62, CHDIR_FREE_Y + 2 + n,
  1837.              CHDIR_FREE_X + 91, CHDIR_FREE_Y + 31,
  1838.              LINE_COL, XWIND_COL, M_PSET);
  1839.         sprintf(buf, "%d", fr * 100 / ta);
  1840.         DSP_msg(buf, CHDIR_FREE_X + 76 - strlen(buf) * 4,
  1841.                  CHDIR_FREE_Y + 8, 0, WIND_COL, CHR_COL, M_PSET);
  1842.         } else {
  1843.             DSP_box(CHDIR_FREE_X, CHDIR_FREE_Y,
  1844.                 CHDIR_FREE_X + 93, CHDIR_FREE_Y + 33,
  1845.                 FILD_COL, M_PSET);
  1846.         }
  1847.         MOS_disp(ON);
  1848.         break;
  1849.  
  1850.     case 3:
  1851.         do {
  1852.         if ( ++now >= 26 ) now = 0;
  1853.         } while ( drv_tbl[now] == IS_NON );
  1854.         MOS_disp(OFF);
  1855.         ICON_disp(CHDIR_DRIV_X,CHDIR_DRIV_Y,now);
  1856.         tmp[0] = '\0';
  1857.         gprintf(CHDIR_DIR_X,CHDIR_DIR_Y,CHR_COL,WIND_COL,"%-34.34s","？");
  1858.         DSP_box(CHDIR_FREE_X, CHDIR_FREE_Y,
  1859.             CHDIR_FREE_X + 93, CHDIR_FREE_Y + 33,
  1860.             FILD_COL, M_PSET);
  1861.         MOS_disp(ON);
  1862.         break;
  1863.  
  1864.     case 4:
  1865.         MOS_disp(OFF);
  1866.         input(CHDIR_DIR_X,CHDIR_DIR_Y,33,tmp);
  1867.         gprintf(CHDIR_DIR_X,CHDIR_DIR_Y,CHR_COL,WIND_COL,"%-34.34s",
  1868.                     tmp[0] == '\0' ? "？":tmp);
  1869.         MOS_disp(ON);
  1870.         break;
  1871.  
  1872.     case 5: cd = TRUE; break;
  1873.     case 6: cd = ERR;  break;
  1874.     }
  1875.     }
  1876.  
  1877.     EVT_free(ep);
  1878.     MOS_disp(OFF);
  1879.     DSP_pop_vram(sp);
  1880.     DSP_clbox(CHDIR_X1,CHDIR_Y1,CHDIR_X2,CHDIR_Y2);
  1881.     MOS_setpos(bx,by);
  1882.     DSP_mos(2);
  1883.     MOS_disp(ON);
  1884.  
  1885.     if ( cd == TRUE ) {
  1886.     if ( chdrv(now) ) {
  1887.         kakunin("ドライブが異常なので処理を中断します");
  1888.         cd = ERR;
  1889.         goto ENDOF;
  1890.     }
  1891.     p = tmp;
  1892.     if ( *p == '\\' ) {
  1893.         chdir("\\");
  1894.         p++;
  1895.     }
  1896.     while ( *p != '\0' ) {
  1897.         if ( (s = strchr(p,'\\')) == NULL ) {
  1898.         for ( s = p ; *s != '\0' ; s++ );
  1899.         fg = TRUE;
  1900.         } else
  1901.         fg = FALSE;
  1902.  
  1903.         *s = '\0';
  1904.  
  1905.         if ( *p == '\0' )
  1906.         break;
  1907.  
  1908.         if ( chdir(p) ) {
  1909.         if ( yesno("%sディレクトリを作成しますか？",p) == ERR ) {
  1910.             cd = ERR;
  1911.             goto ENDOF;
  1912.         }
  1913.         if ( mkdir(p) ) {
  1914.             kakunin("ディレクトリの作成に失敗しました");
  1915.             cd = ERR;
  1916.             goto ENDOF;
  1917.         } else if ( chdir(p) ) {
  1918.             kakunin("ディレクトリの移動に失敗しました");
  1919.             cd = ERR;
  1920.             goto ENDOF;
  1921.         }
  1922.         }
  1923.  
  1924.         if ( fg != FALSE )
  1925.         break;
  1926.         *(s++) = '\\';
  1927.         p = s;
  1928.     }
  1929.  
  1930. /***********************************************************
  1931.     while ( argc-- > 0 && wcopy(*(argv++)) != ERR );
  1932. ************************************************************/
  1933.     zcopy(argc, argv);
  1934.     }
  1935.  
  1936. ENDOF:
  1937.  
  1938.     DSP_mos(0);
  1939. }
  1940.  
  1941. #define    EXEC_X1        (13 * 8 - 4)
  1942. #define    EXEC_Y1        210
  1943. #define    EXEC_X2        (65 * 8 + 3)
  1944. #define    EXEC_Y2        (EXEC_Y1 + 60)
  1945.  
  1946. #define    EXEC_MSG_X    (14 * 8)
  1947. #define    EXEC_MSG_Y    (EXEC_Y1 + 10)
  1948.  
  1949. #define    EXEC_YES_X    ((EXEC_X1+EXEC_X2)/2-(10*8))
  1950. #define    EXEC_YES_Y    (EXEC_Y1 + 34)
  1951.  
  1952. #define    EXEC_NO_X    ((EXEC_X1+EXEC_X2)/2+(2*8))
  1953. #define    EXEC_NO_Y    (EXEC_Y1 + 34)
  1954.  
  1955. int    EXEC_input(char *tmp)
  1956. {
  1957.     int n, cd;
  1958.     int sw,bx,by;
  1959.     BLOCK *sp;
  1960.     EVENT *ep=NULL;
  1961.     char  dmy[256];
  1962.  
  1963.     MOS_disp(OFF);
  1964.     sp = DSP_push_vram(EXEC_X1,EXEC_Y1,EXEC_X2,EXEC_Y2);
  1965.     DSP_opbox(EXEC_X1,EXEC_Y1,EXEC_X2,EXEC_Y2);
  1966.  
  1967.     DSP_wbox(EXEC_X1,EXEC_Y1,EXEC_X2,EXEC_Y2,LINE_COL,FILD_COL,M_PSET);
  1968. /*****************
  1969.     DSP_wbox(EXEC_MSG_X - 4, EXEC_MSG_Y - 2,
  1970.          EXEC_MSG_X + 50 * 8 + 3, EXEC_MSG_Y + 17,
  1971.          LINE_COL,WIND_COL,M_PSET);
  1972. ******************/
  1973.  
  1974.     ep = EVT_img(ep,0,EXEC_YES_X,EXEC_YES_Y,CHR_COL,WIND_COL,64,exec_img);
  1975.     ep = EVT_img(ep,1,EXEC_NO_X, EXEC_NO_Y, CHR_COL,WIND_COL,64,cancel_img);
  1976.     sprintf(dmy, "%-50.50s", tmp);
  1977.     ep = EVT_sw(ep,5,EXEC_MSG_X,EXEC_MSG_Y,CHR_COL,WIND_COL, dmy);
  1978.  
  1979.     MOS_rdpos(&sw,&bx,&by);
  1980.     MOS_setpos((EXEC_X1+EXEC_X2)/2,(EXEC_Y1+EXEC_Y2)/2);
  1981.     MOS_disp(ON);
  1982.  
  1983.     for ( ; ; ) {
  1984.     n = EVT_wait(ep);
  1985.     if ( n == 0 ) {
  1986.         cd = FALSE;
  1987.         break;
  1988.     } else if ( n == 1 ) {
  1989.         cd = ERR;
  1990.         break;
  1991.     } else {
  1992.         MOS_disp(OFF);
  1993.         input(EXEC_MSG_X, EXEC_MSG_Y, 50, tmp);
  1994.         gprintf(EXEC_MSG_X,EXEC_MSG_Y,CHR_COL,WIND_COL,
  1995.         "%-50.50s", tmp);
  1996.         MOS_disp(ON);
  1997.     }
  1998.     }
  1999.  
  2000.     MOS_disp(OFF);
  2001.     DSP_pop_vram(sp);
  2002.     DSP_clbox(EXEC_X1,EXEC_Y1,EXEC_X2,EXEC_Y2);
  2003.     MOS_setpos(bx,by);
  2004.     MOS_disp(ON);
  2005.  
  2006.     return cd;
  2007. }
  2008. /*************************************************************
  2009. 01234567890123456789012345678901234567890123456789012345678901234567890123456789                01234567890123456789012345678901234567890123456
  2010.                 +---------------------------------------------+
  2011. 0               |             ふぁいる せれくた～       | × ||
  2012. 1               |+---++---++---++---++---++---++---++---++---+|
  2013. 2               || A || B || C || D || E || F || G || H || I ||
  2014. 3               |+---++---++---++---++---++---++---++---++---+|
  2015. 4               |+---++---++---++---++---++---++---++---++---+|
  2016. 5               || J || K || L || M || N || O || P || Q || R ||
  2017. 6               |+---++---++---++---++---++---++---++---++---+|
  2018. 7               |******************************************** |
  2019. 8               |xxxxxxxxxx xxx|xxxxxxxxxx xxx|xxxxxxxxxx xxx |
  2020. 9               |xxxxxxxxxx xxx|xxxxxxxxxx xxx|xxxxxxxxxx xxx |
  2021. 10              |xxxxxxxxxx xxx|xxxxxxxxxx xxx|xxxxxxxxxx xxx |
  2022. 11              |xxxxxxxxxx xxx|xxxxxxxxxx xxx|xxxxxxxxxx xxx |
  2023. 12              |xxxxxxxxxx xxx|xxxxxxxxxx xxx|xxxxxxxxxx xxx |
  2024. 13              |ooooooooooooooooooooooooooooooooooooo|＜||＞||
  2025. 14              +---------------------------------------------+
  2026. **************************************************************/
  2027.  
  2028. #define    FSEL_X1        (16*8)
  2029. #define    FSEL_Y1        (240-8*20)
  2030. #define    FSEL_X2        (62*8)
  2031. #define    FSEL_Y2        (FSEL_Y1+264)
  2032.  
  2033. #define    FSEL_MSG_X    (FSEL_X1+23*8)
  2034. #define    FSEL_MSG_Y    (FSEL_Y1+4)
  2035.  
  2036. #define    FSEL_EXIT_X    (FSEL_X1+43*8-2)
  2037. #define    FSEL_EXIT_Y    (FSEL_Y1+4)
  2038.  
  2039. #define    FSEL_DRIV_X    (FSEL_X1+1*8)
  2040. #define    FSEL_DRIV_Y    (FSEL_Y1+24)
  2041.  
  2042. #define    FSEL_DIR_X    (FSEL_X1+1*8)
  2043. #define    FSEL_DIR_Y    (FSEL_Y1+103)
  2044.  
  2045. #define    FSEL_FILE_X    (FSEL_X1+1*8)
  2046. #define    FSEL_FILE_Y    (FSEL_Y1+124)
  2047.  
  2048. #define    FSEL_BACK_X    ((FSEL_X1+FSEL_X2)/2-8*8)
  2049. #define    FSEL_BACK_Y    (FSEL_Y1+240)
  2050.  
  2051. #define    FSEL_NEXT_X    ((FSEL_X1+FSEL_X2)/2+2*8)
  2052. #define    FSEL_NEXT_Y    (FSEL_Y1+240)
  2053.  
  2054. #define    FSEL_DPOS_X1(n)    (FSEL_DRIV_X+((n)%9)*40)
  2055. #define    FSEL_DPOS_Y1(n)    (FSEL_DRIV_Y+((n)/9)*40)
  2056. #define    FSEL_DPOS_X2(n)    (FSEL_DRIV_X+((n)%9)*40+33)
  2057. #define    FSEL_DPOS_Y2(n)    (FSEL_DRIV_Y+((n)/9)*40+33)
  2058.  
  2059. #define    FSEL_FPOS_X1(n)    (FSEL_FILE_X+((n)/5)*15*8-4)
  2060. #define    FSEL_FPOS_Y1(n)    (FSEL_FILE_Y+((n)%5)*22)
  2061. #define    FSEL_FPOS_X2(n)    (FSEL_FILE_X+((n)/5)*15*8+15*8-6)
  2062. #define    FSEL_FPOS_Y2(n)    (FSEL_FILE_Y+((n)%5)*22+19)
  2063.  
  2064. static    char    *HIS_dir(void);
  2065.  
  2066. char    *formname(name)
  2067. char    *name;
  2068. {
  2069.     int     i;
  2070.     char    *p;
  2071.     static char tmp[16];
  2072.  
  2073.     if ( strcmp(name,"..") == 0 || (p = strchr(name,'.')) == NULL )
  2074.         for ( p = name ; *p != '\0' ; p++ );
  2075.  
  2076.     for ( i = 0 ; name < p && i < 8 ; i++ )
  2077.     tmp[i] = *(name++);
  2078.  
  2079.     for ( ; i < 11 ; i++ )
  2080.     tmp[i] = ' ';
  2081.  
  2082.     if ( *p == '.' ) p++;
  2083.  
  2084.     while ( *p != '\0' )
  2085.     tmp[i++] = *(p++);
  2086.  
  2087.     for ( ; i < 14 ; i++ )
  2088.     tmp[i] = ' ';
  2089.  
  2090.     tmp[i] = '\0';
  2091.     return tmp;
  2092. }
  2093. char    *FILE_select(void)
  2094. {
  2095.     int     i,n,cd;
  2096.     int     sw,bx,by;
  2097.     int     drv_old,drv_now;
  2098.     int     pos_old,pos_now;
  2099.     int     dir_flg,dir_max;
  2100.     BLOCK   *sp;
  2101.     EVENT   *ep=NULL;
  2102.     DIR     *dirp;
  2103.     DIRECT  *dp;
  2104.     DIRECT  *file_ptr[15];
  2105.     char    drv_no[26];
  2106.     char    *p;
  2107.     static char tmp[128];
  2108.  
  2109.     MOS_disp(OFF);
  2110.     sp = DSP_push_vram(FSEL_X1,FSEL_Y1,FSEL_X2,FSEL_Y2);
  2111.     DSP_opbox(FSEL_X1,FSEL_Y1,FSEL_X2,FSEL_Y2);
  2112.     DSP_wbox(FSEL_X1,FSEL_Y1,FSEL_X2,FSEL_Y2,LINE_COL,FILD_COL,M_PSET);
  2113.  
  2114.     DSP_strimg(file_selecter_img,
  2115.         FSEL_MSG_X - 46, FSEL_MSG_Y + 3,
  2116.         CHR_COL, FILD_COL, M_PSET);
  2117. /**********
  2118.     gputs(FSEL_MSG_X,FSEL_MSG_Y,CHR_COL,FILD_COL,"FILE SELECTOR");
  2119. ***********/
  2120.  
  2121.     ep = EVT_sw(ep,0,FSEL_EXIT_X,FSEL_EXIT_Y,CHR_COL,WIND_COL,"×");
  2122.     ep = EVT_sw(ep,1,FSEL_BACK_X,FSEL_BACK_Y,CHR_COL,WIND_COL,"  ≪  ");
  2123.     ep = EVT_sw(ep,2,FSEL_NEXT_X,FSEL_NEXT_Y,CHR_COL,WIND_COL,"  ≫  ");
  2124.  
  2125.     for ( i = n = 0 ; n < 18 && i < 26 ; i++ ) {
  2126.     if ( drv_tbl[i] != IS_NON ) {
  2127.         ICON_disp(FSEL_DPOS_X1(n),FSEL_DPOS_Y1(n),i);
  2128.         ep = EVT_set(ep,i+100,
  2129.             FSEL_DPOS_X1(n),FSEL_DPOS_Y1(n),
  2130.                 FSEL_DPOS_X2(n),FSEL_DPOS_Y2(n),EVT_proc);
  2131.         drv_no[i] = n;
  2132.         n++;
  2133.     } else
  2134.         drv_no[i] = 0;
  2135.     }
  2136.  
  2137.     for ( i = 0 ; i < 15 ; i++ ) {
  2138.     ep = EVT_set(ep,i+200,
  2139.         FSEL_FPOS_X1(i),FSEL_FPOS_Y1(i),
  2140.             FSEL_FPOS_X2(i),FSEL_FPOS_Y2(i),EVT_proc);
  2141.     DSP_wbox(FSEL_FPOS_X1(i),FSEL_FPOS_Y1(i),
  2142.              FSEL_FPOS_X2(i),FSEL_FPOS_Y2(i),LINE_COL,WIND_COL,M_PSET);
  2143.     }
  2144.  
  2145.     DSP_wbox(FSEL_DIR_X-4,FSEL_DIR_Y-2,
  2146.          FSEL_DIR_X+(44*8)+2,FSEL_DIR_Y+17,LINE_COL,WIND_COL,M_PSET);
  2147.  
  2148.     ep = EVT_set(ep, 5,
  2149.         FSEL_DIR_X-4, FSEL_DIR_Y-2,
  2150.         FSEL_DIR_X+(44*8)+2, FSEL_DIR_Y+17, EVT_proc);
  2151.  
  2152.     MOS_rdpos(&sw,&bx,&by);
  2153.     MOS_setpos((FSEL_X1+FSEL_X2)/2,(FSEL_Y1+FSEL_Y2)/2);
  2154.     MOS_disp(ON);
  2155.  
  2156.     drv_now = getdrv();
  2157.     drv_old = ERR;
  2158.     dir_flg = TRUE;
  2159.     dirp = NULL;
  2160.     pos_old = ERR;
  2161.     pos_now = 0;
  2162.  
  2163.     for ( cd = FALSE ; cd == FALSE ; ) {
  2164.  
  2165.     if ( drv_old != drv_now ) {
  2166.         MOS_disp(OFF);
  2167.         if ( drv_old != ERR )
  2168.         DSP_box(FSEL_DPOS_X1(drv_no[drv_old]),
  2169.             FSEL_DPOS_Y1(drv_no[drv_old]),
  2170.             FSEL_DPOS_X2(drv_no[drv_old]),
  2171.             FSEL_DPOS_Y2(drv_no[drv_old]),
  2172.             11,M_XOR);
  2173.  
  2174.         DSP_box(FSEL_DPOS_X1(drv_no[drv_now]),
  2175.             FSEL_DPOS_Y1(drv_no[drv_now]),
  2176.             FSEL_DPOS_X2(drv_no[drv_now]),
  2177.             FSEL_DPOS_Y2(drv_no[drv_now]),
  2178.             11,M_XOR);
  2179.         MOS_disp(ON);
  2180.  
  2181.         DSP_mos(2);
  2182.         chdrv(drv_now);
  2183.         DSP_mos(0);
  2184.  
  2185.         drv_old = drv_now;
  2186.         dir_flg = TRUE;
  2187.     }
  2188.  
  2189.     if ( dir_flg != FALSE ) {
  2190.         DSP_mos(2);
  2191.         getdir(tmp);
  2192.  
  2193.         MOS_disp(OFF);
  2194.         gprintf(FSEL_DIR_X,FSEL_DIR_Y,CHR_COL,WIND_COL,"%-44.44s",tmp);
  2195.         MOS_disp(ON);
  2196.  
  2197.         if ( tmp[1] != '\0' )
  2198.         strcat(tmp,"\\");
  2199.         strcat(tmp,"*.*");
  2200.         if ( dirp !=  NULL )
  2201.         closedir(dirp);
  2202.         dirp = opendir(tmp);
  2203.         dir_max = countdir(dirp);
  2204.         pos_now = 0;
  2205.         pos_old = ERR;
  2206.         dir_flg = FALSE;
  2207.         DSP_mos(0);
  2208.     }
  2209.  
  2210.     if ( pos_old != pos_now ) {
  2211.         seekdir(dirp,pos_now);
  2212.         MOS_disp(OFF);
  2213.         for ( i = 0 ; i < 15 ; i++ ) {
  2214.         dp = readdir(dirp);
  2215.         gputs(FSEL_FPOS_X1(i)+4,FSEL_FPOS_Y1(i)+2,
  2216.             (IS_DIR(dp) ? KEY_COL:CHR_COL),WIND_COL,
  2217.             (dp != NULL ? 
  2218.                   formname(dp->d_name):"              "));
  2219.         file_ptr[i] = dp;
  2220.         }
  2221.         MOS_disp(ON);
  2222.         pos_old = pos_now;
  2223.     }
  2224.  
  2225.     i = EVT_wait(ep);
  2226.  
  2227.     if ( i == 0 ) {
  2228.         cd = ERR;
  2229.  
  2230.     } else if ( i == 1 ) {
  2231.         if ( pos_now > 0 )
  2232.         pos_now -= 15;
  2233.  
  2234.     } else if ( i == 2 ) {
  2235.         if ( (pos_now + 15) < dir_max )
  2236.              pos_now += 15;
  2237.  
  2238.     } else if ( i == 5 ) {
  2239.         p = HIS_dir();
  2240.         chdir(p);
  2241.         if ( p[0] != '\0' && p[1] == ':' )
  2242.             drv_now = toupper(p[0]) - 'A';
  2243.         dir_flg = TRUE;
  2244.  
  2245.     } else if ( i >= 200 ) {
  2246.         if ( (dp = file_ptr[i-200]) != NULL ) {
  2247.         if ( IS_DIR(dp) ) {
  2248.             chdir(dp->d_name);
  2249.             dir_flg = TRUE;
  2250.         } else {
  2251.             strcpy(tmp,dp->d_name);
  2252.             cd = TRUE;
  2253.         }
  2254.         }
  2255.  
  2256.     } else if ( i >= 100 ) {
  2257.         drv_now = i - 100;
  2258.         dir_flg = TRUE;
  2259.     }
  2260.     }
  2261.  
  2262.     if ( dirp != NULL )
  2263.     closedir(dirp);
  2264.  
  2265.     EVT_free(ep);
  2266.     MOS_disp(OFF);
  2267.     DSP_pop_vram(sp);
  2268.     DSP_clbox(FSEL_X1,FSEL_Y1,FSEL_X2,FSEL_Y2);
  2269.     MOS_setpos(bx,by);
  2270.     MOS_disp(ON);
  2271.  
  2272.     return (cd == ERR ? NULL:tmp);
  2273. }
  2274.  
  2275. #define    HIS_X1        (18 * 8)
  2276. #define    HIS_X2        (HIS_X1 + 30 * 8 + 8)
  2277. #define    HIS_Y1        (240 - 6 * 20)
  2278. #define    HIS_Y2        (HIS_Y1 + 10 * 22 + 8)
  2279.  
  2280. #define    HIS_FPOS_X1(n)    (HIS_X1 + 4)
  2281. #define    HIS_FPOS_X2(n)    (HIS_X1 + 30 * 8 + 4)
  2282. #define    HIS_FPOS_Y1(n)    (HIS_Y1 + 4 + (n) * 22)
  2283. #define    HIS_FPOS_Y2(n)    (HIS_Y1 + 4 + (n) * 22 + 19)
  2284.  
  2285. static    char    *HIS_dir(void)
  2286. {
  2287.     int     n;
  2288.     int     sw, bx, by;
  2289.     BLOCK   *sp;
  2290.     EVENT   *ep = NULL;
  2291.     static char *his_tab[] = {
  2292.         "G:\\MS_DOS",
  2293.         "G:\\T_OS",
  2294.         "G:\\FB386",
  2295.         "G:\\WINDOWS",
  2296.         "H:\\GEAR",
  2297.         "H:\\GRAPHICS",
  2298.         "H:\\MUSIC\\MIDI",
  2299.         "H:\\MUSIC\\NAIZOU",
  2300.         "G:\\CIRCLE",
  2301.         "G:\\GAME",
  2302.     };
  2303. /**********************
  2304.         "F:\\FB386",
  2305.         "F:\\MS_DOS",
  2306.         "F:\\T_OS",
  2307.         "G:\\MUSIC\\MIDI",
  2308.         "G:\\MUSIC\\NAIZOU",
  2309.         "G:\\GRAPHICS",
  2310.         "F:\\WINDOWS",
  2311.         "G:\\GEAR",
  2312.         "F:\\GAME",
  2313.         "G:\\CIRCLE",
  2314.     };
  2315.     static char *his_tab[] = {
  2316.         "Q:\\CIRCLE",
  2317.         "Q:\\FB386",
  2318.         "Q:\\GAME",
  2319.         "Q:\\GEAR",
  2320.         "Q:\\GRAPHICS",
  2321.         "Q:\\MS_DOS",
  2322.         "Q:\\MUSIC\\MIDI",
  2323.         "Q:\\MUSIC\\NAIZOU",
  2324.         "Q:\\T_OS",
  2325.         "Q:\\WINDOWS",
  2326.     };
  2327. ************************/
  2328.  
  2329.     MOS_disp(OFF);
  2330.     sp = DSP_push_vram(HIS_X1,HIS_Y1,HIS_X2,HIS_Y2);
  2331.     DSP_opbox(HIS_X1,HIS_Y1,HIS_X2,HIS_Y2);
  2332.     DSP_wbox(HIS_X1,HIS_Y1,HIS_X2,HIS_Y2,LINE_COL,FILD_COL,M_PSET);
  2333.  
  2334.     for ( n = 0 ; n < 10 ; n++ ) {
  2335.     ep = EVT_set(ep, n,
  2336.         HIS_FPOS_X1(n), HIS_FPOS_Y1(n),
  2337.             HIS_FPOS_X2(n), HIS_FPOS_Y2(n), EVT_proc);
  2338.     DSP_wbox(HIS_FPOS_X1(n), HIS_FPOS_Y1(n),
  2339.              HIS_FPOS_X2(n), HIS_FPOS_Y2(n), LINE_COL, WIND_COL, M_PSET);
  2340.     gputs(HIS_FPOS_X1(n) + 4, HIS_FPOS_Y1(n) + 2,
  2341.         CHR_COL, WIND_COL, his_tab[n]);
  2342.     }
  2343.  
  2344.     MOS_rdpos(&sw,&bx,&by);
  2345.     MOS_setpos((HIS_X1+HIS_X2)/2,(HIS_Y1+HIS_Y2)/2);
  2346.     MOS_disp(ON);
  2347.  
  2348.     n = EVT_wait(ep);
  2349.  
  2350.     EVT_free(ep);
  2351.     MOS_disp(OFF);
  2352.     DSP_pop_vram(sp);
  2353.     DSP_clbox(HIS_X1,HIS_Y1,HIS_X2,HIS_Y2);
  2354.     MOS_setpos(bx,by);
  2355.     MOS_disp(ON);
  2356.  
  2357.     return his_tab[n];
  2358. }
  2359.